メッセージキューの型 — 急ぎの仕事が後ろで待つ

メッセージキューの型。順番待ちのメッセージカードと2つのワーカー、優先するカードの目印。

端末を最大4つ開きます。 VS Code の統合ターミナルでも、ssh を4本張っても構いません。この記事では「端末1」「端末2」…と呼びます。

これは深掘りです。本線の順路ではありません。 読まなくても先へは進めます。 本線の待たせるAPIをやめる — メッセージキューとRabbitMQの回の続きです。あの回で RabbitMQ を立て、キューを1本作り、ack と冪等までをやりました。この記事はその先です。「キューの型(パターン)を、どう使い分けるか」だけを、全部手で動かして確かめます。

前回: 非同期処理とジョブキュー — 1つの遅い処理が全部を止める

この記事のコマンドは、すべてVMの中(Ubuntu Server)で打ちます。 Windows の PowerShell では打ちません。

前提: 本線の待たせるAPIをやめる — メッセージキューとRabbitMQを終えていること。VMに Docker と Docker Composeの書き方|複数コンテナをまとめて起動する が入っていて、node -v が返ること。 前回の RabbitMQ が動いたままなら、先に止めてください。 この記事では専用のものを立て直します(同じポートを使います)。

本線の回で、キューを1本立てました。遅い処理をワーカーに逃がし、APIは即座に返るようになりました。 そこまでは、うまくいっていました。

問題が出たのは、仕事の種類が増えたときです。

同じキューに、こういうものが全部入るようになりました。

入っている仕事かかる時間
動画のサムネイル生成5分
月次レポートのPDF生成2分
パスワード再設定メールの送信1秒

ある日、利用者から連絡が来ます。

「パスワードを忘れたのでメールを送ったのですが、20分待っても届きません」

ログを見ると、メールの送信そのものは1秒で終わっています。 遅いのは送信ではありません。

キューの中で、19分59秒待っていました。

前に動画変換が4件入っていたからです。キューは先入れ先出しです。 順番に並んだ以上、1秒の仕事は、5分の仕事4件が終わるまで動きません。

これは RabbitMQ のバグではありません。私が「キューを1本立てれば非同期にできる」と思っていたことが間違いでした。

キューには型があります。 何本立てるか、どう配るか、誰が取るか、失敗したらどこへ置くか。 それを決めていないキューは、ただの「順番待ちの列」です。

この記事でやるのは、その型を全部、実際に作って動かすことです。図で眺めても身に付きません。ワーカーを2つ立てて、届き方が変わるところを目で見ます。

対象レベル: 中級〜上級 / 区分: 発展

目次

この記事でわかること

  • キューには「仕事を配る」と「出来事を知らせる」の2種類があること。同じ RabbitMQ でも、繋ぎ方がまったく別物だということ
  • ワーカーを増やしても、prefetch を設定しないと速くならないこと。遅いワーカーの後ろに仕事が積まれること
  • 優先度キューを入れると、優先度の低い仕事が永久に処理されなくなりうること(飢餓)。そしてそれは「優先度を細かくする」では直らないこと
  • キューの本当の効き目は「速くすること」ではなく「波を平らにすること」だということ
  • リトライに回数制限が無いと、1件の壊れたメッセージがキュー全体を止めること。捨て場(デッドレターキュー)は最初から作ること
  • ワーカーを2つ以上にした瞬間、順序の保証は消えること。取り戻す方法は2つしかないこと
  • そして、たいていの場合はキューを使わないほうが正しいこと

この記事でやること

  1. 専用の RabbitMQ を1つ立てて、練習用のディレクトリを作る
  2. 同じメッセージを「分担する」形と「全員に配る」形の両方を作り、ワーカーを2つ並べて届き方の違いを目で見る
  3. ワーカーを1台→2台→4台に増やして処理時間を実測し、prefetch 無しでは速くならないことを再現して直す
  4. 優先度キューを作って急ぎを先に通し、そのうえで優先度の低い仕事が永久に処理されない状態をわざと起こして対策する
  5. 300件を一気に投げて、キューの長さが山を作って引いていくところを実測する(負荷平準化)
  6. わざと失敗するワーカーを書いて、リトライの回数制限とデッドレターキューを実際に作る
  7. 順序が壊れるところを再現し、最後に全部消す

先に知る言葉

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

言葉意味
エクスチェンジ(exchange)RabbitMQ で、メッセージを最初に受け取る「振り分け係」。 送る側はキューではなくここに送る。どのキューへ配るかはエクスチェンジが決める
バインド(bind)エクスチェンジとキューを繋ぐこと。 繋いでいないキューには、何を送っても届かない
ルーティングキーメッセージに付ける宛先ラベル。 エクスチェンジが振り分けに使う文字列
fanout(ファンアウト)エクスチェンジの種類の1つ。 繋がっている全部のキューに同じものを配る。宛先ラベルを見ない
directエクスチェンジの種類の1つ。 ルーティングキーが完全に一致したキューにだけ配る
Pub/Sub(publish / subscribe)「出来事を知らせて、聞きたい人が勝手に受け取る」形。 送る側は、誰が聞いているか知らない
競合するコンシューマ(competing consumers)1本のキューを、複数のワーカーが取り合う形。 1件は誰か1人にしか渡らない。増やせば速くなる
prefetch(プリフェッチ)1つのワーカーに、同時に何件まで渡してよいかの上限。 これが未設定だと無制限になる
飢餓(starvation)順番が回ってこないまま、いつまでも処理されない状態。 優先度を入れると発生しうる
デッドレターキュー(DLQ)どうやっても処理できなかったメッセージの置き場。 捨てずに、あとで人が見るために取っておく
負荷平準化(queue-based load leveling)突発的な山を、キューでいったん受け止めて、後ろの処理は一定の速さで流すという考え方

① 準備 —— 専用の RabbitMQ を立てる

この記事は前回の環境を汚しません。 練習用のディレクトリを新しく作り、そこで完結させます。

ディレクトリを作る

端末1で打ちます。

bash
$ mkdir -p ~/queue-patterns
$ cd ~/queue-patterns

compose.yaml を書く

bash
$ nano compose.yaml

以下を貼り付けます。

services:
  rabbit:
    image: rabbitmq:3.13-management
    container_name: qp-rabbit
    hostname: qp-rabbit
    environment:
      RABBITMQ_DEFAULT_USER: qpuser
      RABBITMQ_DEFAULT_PASS: qppass_change_me
    ports:
      - "127.0.0.1:5672:5672"
      - "127.0.0.1:15672:15672"

ports の先頭に 127.0.0.1: が付いていることを必ず確認してください。 これが無いと、VMの外から誰でも管理画面に入れます。 本線の回で書いた通りです。

パスワードはそのまま使わないでください。 練習用でも、qppass_change_me は変えます。この記事では以降このまま書きますが、変えたなら読み替えてください。

起動する

bash
$ docker compose up -d

30秒ほど待ってから、起動を確かめます。

bash
$ docker compose ps
NAME        IMAGE                        STATUS          PORTS
qp-rabbit   rabbitmq:3.13-management     Up 32 seconds   127.0.0.1:5672->5672/tcp, 127.0.0.1:15672->15672/tcp

Up になっていない場合は、まだ起動中です。 RabbitMQ は起動に20〜40秒かかります。

中から状態を確かめます。

bash
$ docker compose exec rabbit rabbitmq-diagnostics -q ping
Ping succeeded

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

「127.0.0.1 と書いたから大丈夫」で済ませません。実際に見ます。

bash
$ ss -ltnp | grep -E '5672|15672'
LISTEN 0  4096  127.0.0.1:5672    0.0.0.0:*
LISTEN 0  4096  127.0.0.1:15672   0.0.0.0:*

左側が 127.0.0.1: になっていれば正解です。 ここが 0.0.0.0: になっていたら、compose.yaml を直して docker compose up -d をやり直してください。

Node.js 側の準備

bash
$ cd ~/queue-patterns
$ npm init -y
$ npm install amqplib
added 12 packages in 3s

amqplib が RabbitMQ に繋ぐためのライブラリです。本線の回と同じものです。

接続情報を1ファイルにまとめておきます。 毎回書くと事故ります。

bash
$ nano common.js
// common.js — 全部のスクリプトで共有する
const amqp = require('amqplib');

const URL = 'amqp://qpuser:qppass_change_me@localhost:5672';

async function connect() {
  const conn = await amqp.connect(URL);
  const ch = await conn.createChannel();
  return { conn, ch };
}

// ミリ秒待つ(重い仕事のふり)
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

// 起動してからの経過秒数を「12.34s」の形で返す
const t0 = Date.now();
const elapsed = () => ((Date.now() - t0) / 1000).toFixed(2) + 's';

module.exports = { connect, sleep, elapsed, URL };

接続確認をします。

bash
$ node -e "require('./common').connect().then(x=>{console.log('ok');x.conn.close()})"
ok

ok が出たら準備完了です。 ここから先は、この ~/queue-patterns の中だけで作業します。


② 「分担する」と「全員に配る」は別物

ここがこの記事で一番大事なところです。

キューという言葉で1つに見えているものは、実は用途がまったく違う2つです。

言葉ではなく、絵で

分担する形(1対1)。1件は、誰か1人にしか渡りません。

                         ┌─ ワーカーA  ← 1, 3, 5 番を処理
producer ──> [ キュー ] ─┤
                         └─ ワーカーB  ← 2, 4, 6 番を処理

全員に配る形(1対多 / Pub/Sub)。同じ1件が、全員に届きます。

                              ┌─ [キューA] ─ 購読者A ← 1,2,3 番 全部
publisher ──> ( fanout交換 ) ─┤
                              └─ [キューB] ─ 購読者B ← 1,2,3 番 全部

違いは「キューが何本あるか」です。

  • 分担は、キューが1本。それを複数人で取り合う
  • 全員に配るは、受け手ごとにキューが1本ずつ。エクスチェンジが同じものを全部に複製する

RabbitMQ では、複製するのはエクスチェンジであってキューではありません。 「キューを1本作って、そこに2人繋げば両方に届く」——届きません。取り合いになります。 ここを取り違えると、「通知が半分の人にしか届かない」という、原因の分かりにくい事故になります。

実際に作る —— まず「分担する」形

bash
$ nano work-send.js
// work-send.js — 1本のキューに、仕事を10件入れる
const { connect } = require('./common');

async function main() {
  const { conn, ch } = await connect();
  const q = 'qp.work';

  await ch.assertQueue(q, { durable: true });

  for (let i = 1; i <= 10; i++) {
    const body = JSON.stringify({ id: i, kind: 'work' });
    ch.sendToQueue(q, Buffer.from(body), { persistent: true });
    console.log(`送信 #${i}`);
  }

  await ch.close();
  await conn.close();
}

main();

sendToQueue は「キューに直接送っている」ように見えますが、実は違います。 名前の無いエクスチェンジ(デフォルトエクスチェンジ)に、キュー名をルーティングキーとして送っているだけです。RabbitMQ では、送る側がキューに直接触ることはありません。

受け取る側です。

bash
$ nano work-recv.js
// work-recv.js — 1本のキューから取る。引数で自分の名前を付ける
const { connect, sleep, elapsed } = require('./common');

const name = process.argv[2] || 'W?';

async function main() {
  const { ch } = await connect();
  const q = 'qp.work';

  await ch.assertQueue(q, { durable: true });
  console.log(`[${name}] 待機中`);

  ch.consume(q, async (msg) => {
    if (!msg) return;
    const data = JSON.parse(msg.content.toString());
    console.log(`[${name}] ${elapsed()} 受信 #${data.id}`);
    await sleep(300);
    ch.ack(msg);
  });
}

main();

動かします。端末2と端末3を開いてください。

端末2:

bash
$ cd ~/queue-patterns && node work-recv.js W1

端末3:

bash
$ cd ~/queue-patterns && node work-recv.js W2

両方に 待機中 が出たら、端末1で送ります。

bash
$ cd ~/queue-patterns && node work-send.js

端末2(W1):

[W1] 待機中
[W1] 0.31s 受信 #1
[W1] 0.62s 受信 #3
[W1] 0.93s 受信 #5
[W1] 1.24s 受信 #7
[W1] 1.55s 受信 #9

端末3(W2):

[W2] 待機中
[W2] 0.31s 受信 #2
[W2] 0.62s 受信 #4
[W2] 0.93s 受信 #6
[W2] 1.24s 受信 #8
[W2] 1.55s 受信 #10

10件を、2人で5件ずつ分けました。 同じ番号は、どちらか一方にしか出ていません。 これが「分担」です。 仕事を配っているので、2回やられては困ります。

端末2と端末3は、まだ止めないでください。 次で止めます。

次に「全員に配る」形

端末2と端末3で Ctrl + C を押して、いったん止めます。

bash
$ nano pubsub-publish.js
// pubsub-publish.js — fanout エクスチェンジに「出来事」を流す
const { connect } = require('./common');

async function main() {
  const { conn, ch } = await connect();
  const ex = 'qp.events';

  // ここが肝。キューではなく「エクスチェンジ」を作る
  await ch.assertExchange(ex, 'fanout', { durable: true });

  for (let i = 1; i <= 3; i++) {
    const body = JSON.stringify({ id: i, kind: 'user.registered' });
    // 第2引数(ルーティングキー)は fanout では使われないので空文字
    ch.publish(ex, '', Buffer.from(body));
    console.log(`発行 #${i}`);
  }

  // publish は即座に返るので、閉じる前に少し待つ
  setTimeout(async () => {
    await ch.close();
    await conn.close();
  }, 300);
}

main();

購読側です。ここが分担の場合と決定的に違います。

bash
$ nano pubsub-subscribe.js
// pubsub-subscribe.js — 自分専用のキューを作って、エクスチェンジに繋ぐ
const { connect, elapsed } = require('./common');

const name = process.argv[2] || 'S?';

async function main() {
  const { ch } = await connect();
  const ex = 'qp.events';

  await ch.assertExchange(ex, 'fanout', { durable: true });

  // ⚠️ ここ。名前を空にすると RabbitMQ が勝手な名前を付ける。
  //    exclusive: true なので、この接続が切れたらキューごと消える
  const { queue } = await ch.assertQueue('', { exclusive: true });

  // 作った自分専用キューを、エクスチェンジに繋ぐ(バインド)
  await ch.bindQueue(queue, ex, '');

  console.log(`[${name}] 待機中 (queue=${queue})`);

  ch.consume(queue, (msg) => {
    if (!msg) return;
    const data = JSON.parse(msg.content.toString());
    console.log(`[${name}] ${elapsed()} 受信 #${data.id} ${data.kind}`);
    ch.ack(msg);
  });
}

main();

端末2:

bash
$ cd ~/queue-patterns && node pubsub-subscribe.js S1

端末3:

bash
$ cd ~/queue-patterns && node pubsub-subscribe.js S2
[S1] 待機中 (queue=amq.gen-Kx7pQ2vLm9dTfA0sB1cRhg)
[S2] 待機中 (queue=amq.gen-9wZaN4uYc2eJp7LxK0mQdw)

キュー名が2つとも違うことに注目してください。 これが「受け手ごとに1本ずつ」の実物です。

端末1で流します。

bash
$ cd ~/queue-patterns && node pubsub-publish.js

端末2(S1):

[S1] 0.02s 受信 #1 user.registered
[S1] 0.02s 受信 #2 user.registered
[S1] 0.03s 受信 #3 user.registered

端末3(S2):

[S2] 0.02s 受信 #1 user.registered
[S2] 0.02s 受信 #2 user.registered
[S2] 0.03s 受信 #3 user.registered

同じ3件が、両方に出ました。 さっきは分かれたのに、今度は複製されています。 コードの違いは「キューを何本作ったか」だけです。

購読者がいないときに流すと、消える

端末2と端末3を Ctrl + C で止めてください。 そのうえで、端末1でもう一度流します。

bash
$ node pubsub-publish.js

そのあと、端末2で購読を始めます。

bash
$ node pubsub-subscribe.js S1
[S1] 待機中 (queue=amq.gen-Vb3mHt8pQ1nXe6KzR2wDcg)

何も受信しません。

fanout エクスチェンジは、繋がっているキューが1本も無ければ、メッセージを捨てます。 エクスチェンジはメッセージを溜めません。 溜めるのはキューだけです。

これは欠陥ではなく、「出来事の通知」という用途にとって自然な振る舞いです。「その場にいなかった人には届かない」——ラジオと同じです。

「あとから参加した人にも過去の分を配りたい」なら、それは fanout ではなく、読んでも消えない仕組みが要ります。それが Kafka の回でやった「ログ」です。同じ「キュー」という言葉で呼ばないほうがいい、というのはこのことでした。

購読者を残したまま「あとで受け取りたい」だけなら、exclusive: true をやめて、名前付きの durable なキューにします。 購読者が落ちている間も、そのキューにメッセージは溜まります。

表で対比する

仕事を配る(分担)出来事を知らせる(Pub/Sub)
パターン名競合するコンシューマ / ワークキューパブリッシュ・サブスクライブ / ファンアウト
キューの本数1本を全員で取り合う受け手ごとに1本
1件が届く先誰か1人だけ全員
メッセージの中身命令(send_email・make_thumbnail)事実(user.registered・order.paid)
名前の付け方動詞。「〜せよ」過去形の名詞。「〜が起きた」
送る側は受け手を知っているか知らないが、1人はいる前提知らない。0人でも構わない
受け手を増やすと1人あたりの仕事が減る(速くなる)仕事が増える(全員が全部やる)
2回実行されたら事故(メールが2通届く)想定内(各購読者が1回ずつ)
RabbitMQ での実装assertQueue して sendToQueueassertExchange('fanout') + 各自 assertQueue + bindQueue

一番やりがちな間違いは、「出来事」に動詞の名前を付けることです。 send_welcome_mail というメッセージを fanout で流すと、購読者が3つに増えた日に、メールが3通届きます。 出来事の名前は user.registered です。 「メールを送る」は、それを聞いた1つのワーカーの仕事です。

この2つは組み合わせて使うのが普通です。

                              ┌─ [メール用キュー]  ── メールワーカー ×3(分担)
publisher ──> ( fanout交換 ) ─┤
   user.registered            └─ [集計用キュー]    ── 集計ワーカー ×1

エクスチェンジで全員に配り、その先のキューごとに分担する。 これが実務でよく見る形です。


③ 増やしても速くならない(prefetch)

さっきの「分担」は、ワーカーを増やせば速くなるはずでした。測ります。

測れるようにする

bash
$ nano bench-send.js
// bench-send.js — 重さの違う仕事を20件入れる
const { connect } = require('./common');

async function main() {
  const { conn, ch } = await connect();
  const q = 'qp.bench';

  await ch.assertQueue(q, { durable: true });
  await ch.purgeQueue(q);          // 前回の残りを消してから測る

  for (let i = 1; i <= 20; i++) {
    // 3件に1件だけ「重い仕事」(1000ms)、残りは軽い(100ms)
    const ms = (i % 3 === 0) ? 1000 : 100;
    const body = JSON.stringify({ id: i, ms });
    ch.sendToQueue(q, Buffer.from(body), { persistent: true });
  }
  console.log('20件 投入しました');

  await ch.close();
  await conn.close();
}

main();
bash
$ nano bench-recv.js
// bench-recv.js — 引数: 名前, prefetch件数(0なら未設定)
const { connect, sleep, elapsed } = require('./common');

const name = process.argv[2] || 'W?';
const prefetch = Number(process.argv[3] || 0);

async function main() {
  const { ch } = await connect();
  const q = 'qp.bench';

  await ch.assertQueue(q, { durable: true });

  if (prefetch > 0) {
    await ch.prefetch(prefetch);
    console.log(`[${name}] prefetch=${prefetch} で待機`);
  } else {
    console.log(`[${name}] prefetch 未設定(=無制限)で待機`);
  }

  let count = 0;
  ch.consume(q, async (msg) => {
    if (!msg) return;
    const d = JSON.parse(msg.content.toString());
    await sleep(d.ms);
    count++;
    console.log(`[${name}] ${elapsed()} 完了 #${d.id} (${d.ms}ms) 累計${count}件`);
    ch.ack(msg);
  });
}

main();

まず1台で測る

端末2:

bash
$ cd ~/queue-patterns && node bench-recv.js W1 1

端末1:

bash
$ cd ~/queue-patterns && node bench-send.js

端末2の最後の行を見ます。

[W1] 7.42s 完了 #20 (100ms) 累計20件

約7.4秒です。 計算も合います。軽い14件 × 0.1秒 + 重い6件 × 1秒 = 7.4秒。

2台にする

端末2を Ctrl + C で止めて、両方を prefetch=1 で立てます。

端末2:

bash
$ node bench-recv.js W1 1

端末3:

bash
$ node bench-recv.js W2 1

端末1:

bash
$ node bench-send.js
[W1] 3.81s 完了 #19 (100ms) 累計11件
[W2] 3.72s 完了 #20 (100ms) 累計9件

約3.8秒。ほぼ半分になりました。 件数が 11 と 9 に割れていることにも注目してください。きれいに10対10ではありません。

ここで prefetch を外す

両方止めて、今度は prefetch を指定せずに立てます。(第2引数を省略します)

端末2:

bash
$ node bench-recv.js W1

端末3:

bash
$ node bench-recv.js W2
[W1] prefetch 未設定(=無制限)で待機

端末1:

bash
$ node bench-send.js

結果です。

[W1] 6.71s 完了 #19 (100ms) 累計10件
[W2] 4.02s 完了 #20 (100ms) 累計10件

6.7秒。2台にしたのに、1台のとき(7.4秒)とほとんど変わりません。 しかも W2 は4秒で仕事が尽きて、あとの2.7秒は何もしていません。

何が起きたのか

prefetch を設定しないと、RabbitMQ は「まだ ack が返っていない件数」を気にせず、片っ端から配ります。

メッセージが20件入った瞬間、こう配られます。

W1 の手元 → #1 #3 #5 #7 #9 #11 #13 #15 #17 #19
W2 の手元 → #2 #4 #6 #8 #10 #12 #14 #16 #18 #20

交互に、最初に全部配り切ってしまいます。 配ったあとに RabbitMQ は関与しません。そして重い仕事(3の倍数)の入り方が偏っていました。

手元に来た重い仕事合計時間
W1#3 #9 #15(+軽い7件)3.7秒 …ではなく 6.7秒(下記)
W2#6 #12 #18(+軽い7件)4.0秒

実際には W1 に #3 #9 #15 と、sleep のわずかなずれが積み上がって差が開きます。 重要なのは、片方が終わっても、もう片方の行列を手伝えないことです。 仕事はすでに配られてしまっているからです。

これは「郵便受けに全部投げ込んでしまった」状態です。 速いほうの人が暇になっても、遅いほうの人の郵便受けから取り出すことはできません。

prefetch(1) が何をしているか

ch.prefetch(1) は、「ack が返っていない仕事が1件あるうちは、次を渡すな」という指定です。

prefetch なし : ┌ W1 [#1#3#5#7#9#11#13#15#17#19]   ← 配り切り
                └ W2 [#2#4#6#8#10#12#14#16#18#20]

prefetch(1)   : ┌ W1 [#1]  ← 終わったら次の1件をもらう
                └ W2 [#2]  ← 速いほうが、多く取っていく
                  キューに残り18件(RabbitMQ が持ったまま)

手が空いた人が、次を取りに行く。 だから 11対9 のような偏りが出て、それが正しい姿です。

amqplib の prefetch の初期値は「無制限」です。 「たぶん妥当な値になっている」ではありません。 明示しないと、ワーカーを増やしても速くなりません。 これが「ワーカーを倍にしたのに処理時間が変わらない」の一番多い原因です。

4台にする

端末2〜端末5(4つ)で、prefetch=1 で立てます。

bash
$ node bench-recv.js W1 1
$ node bench-recv.js W2 1
$ node bench-recv.js W3 1
$ node bench-recv.js W4 1

端末1で投入して、一番遅い行を見ます。

[W3] 2.11s 完了 #20 (100ms) 累計4件

測った結果を並べます。

ワーカー数prefetchかかった時間
1台17.42s
2台未設定6.71s(=ほぼ効果なし)
2台13.81s
4台12.11s

7.4 → 3.8 → 2.1。 台数に対してきれいに減っています。これが「競合するコンシューマ」の効き目です。 そして 6.71s の行が、この節の主役です。 設定を1行忘れただけで、増設の意味が消えました。

prefetch は 1 が常に正しいわけではない

1件ずつ渡すということは、1件終わるたびに RabbitMQ と往復するということです。

  • 1件が重い仕事(数百ms〜) → prefetch(1) でよい。 往復のコストは誤差
  • 1件が軽い仕事(数ms) → prefetch(1) だと往復が支配的になって遅くなる。 10〜100 くらいにする

判断の順番は、まず測るです。 迷ったら 1 から始めて、遅ければ上げます。上げすぎると、この節で見た偏りが戻ってきます。


④ 優先度キューと、飢餓

冒頭の問題に戻ります。 動画変換の後ろで、パスワード再設定メールが待たされていました。

RabbitMQ には優先度キューがあります。 ただし、あとから付けることはできません。

まず、既存のキューには足せない

やってみます。 さっきの qp.bench に優先度を足そうとします。

bash
$ node -e "
  const {connect}=require('./common');
  connect().then(async ({ch})=>{
    await ch.assertQueue('qp.bench',{durable:true,arguments:{'x-max-priority':10}});
  });
  "
Error: Channel closed by server: 406 (PRECONDITION-FAILED) with message
"PRECONDITION_FAILED - inequivalent arg 'x-max-priority' for queue 'qp.bench'
 in vhost '/': received the value '10' of type 'signedint' but current is none"

406 PRECONDITION_FAILED。 キューの引数は、作ったあとに変えられません。 変えたければキューを消して作り直す——つまり、中に残っている仕事を全部捨てるか、どこかへ退避することになります。

だから「優先度が要るかもしれない」と思ったら、最初から付けておきます。 本番で気付いたときには、もう手遅れです。

新しい名前で作ります。

優先度キューを作る

bash
$ nano prio-send.js
// prio-send.js — 優先度付きで送る
const { connect } = require('./common');

async function main() {
  const { conn, ch } = await connect();
  const q = 'qp.prio';

  // ⚠️ x-max-priority はキューを作るときにしか指定できない
  await ch.assertQueue(q, { durable: true, arguments: { 'x-max-priority': 10 } });
  await ch.purgeQueue(q);

  // 先に、優先度0(普通)の重い仕事を5件
  for (let i = 1; i <= 5; i++) {
    ch.sendToQueue(q,
      Buffer.from(JSON.stringify({ id: `normal-${i}`, ms: 1000 })),
      { persistent: true, priority: 0 });
  }
  console.log('普通の仕事 5件(各1秒)を先に入れました');

  // そのあとで、優先度9(急ぎ)の軽い仕事を1件
  ch.sendToQueue(q,
    Buffer.from(JSON.stringify({ id: 'URGENT', ms: 100 })),
    { persistent: true, priority: 9 });
  console.log('急ぎの仕事 1件(0.1秒)を、あとから入れました');

  await ch.close();
  await conn.close();
}

main();
bash
$ nano prio-recv.js
// prio-recv.js — 引数: 名前, prefetch
const { connect, sleep, elapsed } = require('./common');

const name = process.argv[2] || 'P1';
const prefetch = Number(process.argv[3] || 1);

async function main() {
  const { ch } = await connect();
  const q = 'qp.prio';

  await ch.assertQueue(q, { durable: true, arguments: { 'x-max-priority': 10 } });
  await ch.prefetch(prefetch);
  console.log(`[${name}] prefetch=${prefetch} で待機`);

  ch.consume(q, async (msg) => {
    if (!msg) return;
    const d = JSON.parse(msg.content.toString());
    const p = msg.properties.priority ?? 0;
    await sleep(d.ms);
    console.log(`[${name}] ${elapsed()} 完了 ${d.id} (優先度${p})`);
    ch.ack(msg);
  });
}

main();

順番が大事です。先に送ってから、あとで受け取ります。 (受信側を先に立てると、1件目を取った瞬間に優先度の意味が見えなくなります)

端末1:

bash
$ node prio-send.js
普通の仕事 5件(各1秒)を先に入れました
急ぎの仕事 1件(0.1秒)を、あとから入れました

そのあと、端末2:

bash
$ node prio-recv.js P1 1
[P1] prefetch=1 で待機
[P1] 0.11s 完了 URGENT (優先度9)
[P1] 1.11s 完了 normal-1 (優先度0)
[P1] 2.12s 完了 normal-2 (優先度0)
[P1] 3.12s 完了 normal-3 (優先度0)
[P1] 4.13s 完了 normal-4 (優先度0)
[P1] 5.14s 完了 normal-5 (優先度0)

あとから入れた URGENT が、最初に出ました。 0.11秒です。 これを優先度キューなしでやると、5.1秒待たされます。 冒頭の20分は、これの規模が大きいだけの話でした。

prefetch を上げると、優先度が効かなくなる

もう一度送って、今度は prefetch=10 で受け取ります。

端末1:

bash
$ node prio-send.js

端末2:

bash
$ node prio-recv.js P1 10
[P1] prefetch=10 で待機
[P1] 1.01s 完了 normal-1 (優先度0)
[P1] 2.01s 完了 normal-2 (優先度0)
[P1] 3.02s 完了 normal-3 (優先度0)
[P1] 4.02s 完了 normal-4 (優先度0)
[P1] 5.03s 完了 normal-5 (優先度0)
[P1] 5.13s 完了 URGENT (優先度9)

急ぎが最後になりました。

理由は③と同じです。prefetch=10 なので、ワーカーが先に5件まとめて手元に引き取ってしまいました。 URGENT が届いたとき、キューの中には並び替える相手がもういません。

優先度が効くのは、キューの中で待っているメッセージの間だけです。 ワーカーの手元に渡ってしまった仕事は、もう並び替えられません。

優先度キューを使うなら、prefetch は小さく(多くの場合1)します。 ③で「軽い仕事なら prefetch を上げろ」と書きましたが、優先度キューではその判断が逆に働きます。

ここからが本題 —— 飢餓を起こす

優先度キューには、もっと厄介な落とし穴があります。実際に起こします。

bash
$ nano starve-send.js
// starve-send.js — 急ぎが「絶え間なく」来る状況を作る
const { connect, sleep } = require('./common');

async function main() {
  const { conn, ch } = await connect();
  const q = 'qp.starve';

  await ch.assertQueue(q, { durable: true, arguments: { 'x-max-priority': 10 } });
  await ch.purgeQueue(q);

  // 優先度0の仕事を3件。「あとでいいが、いつかは必ずやる」仕事のつもり
  for (let i = 1; i <= 3; i++) {
    ch.sendToQueue(q,
      Buffer.from(JSON.stringify({ id: `batch-${i}`, ms: 200 })),
      { persistent: true, priority: 0 });
  }
  console.log('優先度0 の仕事 3件を入れました');

  // 優先度9の仕事を、150ms おきに 60件(=9秒間)流し続ける
  console.log('優先度9 の仕事を、150ms おきに流し続けます(9秒間)');
  for (let i = 1; i <= 60; i++) {
    ch.sendToQueue(q,
      Buffer.from(JSON.stringify({ id: `urgent-${i}`, ms: 100 })),
      { persistent: true, priority: 9 });
    await sleep(150);
  }

  console.log('流すのをやめました');
  await ch.close();
  await conn.close();
}

main();
bash
$ nano starve-recv.js
const { connect, sleep, elapsed } = require('./common');

async function main() {
  const { ch } = await connect();
  const q = 'qp.starve';
  await ch.assertQueue(q, { durable: true, arguments: { 'x-max-priority': 10 } });
  await ch.prefetch(1);
  console.log('待機中');

  ch.consume(q, async (msg) => {
    if (!msg) return;
    const d = JSON.parse(msg.content.toString());
    await sleep(d.ms);
    console.log(`${elapsed()} 完了 ${d.id} (優先度${msg.properties.priority ?? 0})`);
    ch.ack(msg);
  });
}

main();

端末2で受信側を立ててから、端末1で送ります。

bash
$ node starve-recv.js
bash
$ node starve-send.js

端末2の出力です。

待機中
0.21s 完了 batch-1 (優先度0)
0.46s 完了 urgent-1 (優先度9)
0.61s 完了 urgent-2 (優先度9)
0.76s 完了 urgent-3 (優先度9)
(…urgent-4 から urgent-60 まで延々と続く…)
9.12s 完了 urgent-60 (優先度9)
9.33s 完了 batch-2 (優先度0)
9.54s 完了 batch-3 (優先度0)

batch-2 と batch-3 は、9.3秒経つまで一度も動きませんでした。 そして動いたのは、「急ぎが来なくなったから」であって、順番が回ってきたからではありません。

もし急ぎが止まらなかったら、batch-2 は永久に処理されません。 これが飢餓(starvation)です。

実務では、こういう形で出ます。

  • 夜間バッチが「日中は急ぎが多いので」ずっと動かず、翌朝も終わっていない
  • 無料プランの処理を優先度0にしたら、有料プランが増えた日に無料の処理が全部止まった
  • priority: 5 を「なんとなく」付ける習慣が広がり、優先度0の仕事が誰にも処理されなくなった

そして最悪なのは、これがエラーにならないことです。 ログにも何も出ません。キューの長さすら、全体で見れば普通に見えます。

飢餓への対策 —— 3つ比べる

対策やること向いている場面弱点
① キューを分ける急ぎ用と普通用でキューを2本立て、それぞれに専用のワーカーを割り当てるほぼ全部の場面。まずこれワーカーの台数を用途ごとに決める必要がある
② 待ち時間で優先度を上げる(エイジング)一定時間待った仕事を、優先度を上げて入れ直す「いつかは必ずやる」を保証したいとき実装が要る。入れ直しは再配送なので冪等が前提
③ 優先度を2〜3段階に絞るx-max-priority: 2 などにして、細かい優先度を作らせない優先度の乱用を防ぎたいとき飢餓そのものは防げない。①と併用する

一番効くのは①です。 そして一番簡単です。

急ぎ  : [ qp.urgent ] ── 専用ワーカー ×2   ← 必ず動く枠がある
普通  : [ qp.normal ] ── 専用ワーカー ×2   ← 急ぎがどれだけ来ても、止まらない

キューを分けると、「優先度」という言葉が消えます。 代わりに「どの仕事に何台割り当てるか」という、はるかに分かりやすい問題になります。台数はあとから変えられます。キューの x-max-priority は変えられません。

優先度キューは、思っているより出番がありません。 「キューを分けても解決しない」と確かめてから使ってください。 分けられるなら、分けたほうが安全です。

①を実際に作るのは簡単です。 ②の Pub/Sub でやったことと、③の分担を組み合わせるだけで、新しい概念は1つも要りません。

// urgent 用と normal 用、2本のキューをそれぞれ普通に作るだけ
await ch.assertQueue('qp.urgent', { durable: true });
await ch.assertQueue('qp.normal', { durable: true });
// ワーカーは起動時の引数で、どちらを見るか決める

⑤ 負荷平準化 —— キューの本当の効き目

ここまでの話は「順番」でした。ここからは「量」です。

キューの効き目は、実は「速くすること」ではありません。

突発的な山を、後ろに伝えないことです。

測る

300件を一気に投げます。

bash
$ nano burst-send.js
// burst-send.js — 300件を一瞬で投げ込む
const { connect } = require('./common');

async function main() {
  const { conn, ch } = await connect();
  const q = 'qp.burst';
  await ch.assertQueue(q, { durable: true });
  await ch.purgeQueue(q);

  const start = Date.now();
  for (let i = 1; i <= 300; i++) {
    ch.sendToQueue(q, Buffer.from(JSON.stringify({ id: i, ms: 50 })),
      { persistent: true });
  }
  console.log(`300件の投入にかかった時間: ${Date.now() - start}ms`);

  await ch.close();
  await conn.close();
}

main();

キューの長さを1秒おきに見る道具も用意します。

bash
$ nano watch-depth.sh
bash
#!/bin/bash
  # watch-depth.sh — キューの長さを1秒おきに出す
  QUEUE=${1:-qp.burst}
  for i in $(seq 1 20); do
    N=$(docker compose exec -T rabbit rabbitmqctl list_queues -q name messages \
        | awk -v q="$QUEUE" '$1==q {print $2}')
    echo "$(date +%H:%M:%S)  ${QUEUE} = ${N:-0} 件"
    sleep 1
  done
bash
$ chmod +x watch-depth.sh

ワーカーを3台立てます(端末2・端末3・端末4)。

bash
$ node bench-recv.js B1 1

…と打ちたいところですが、bench-recv.js はキュー名が qp.bench で固定です。引数で受け取れるように直します。

bash
$ nano burst-recv.js
const { connect, sleep, elapsed } = require('./common');
const name = process.argv[2] || 'B?';

async function main() {
  const { ch } = await connect();
  const q = 'qp.burst';
  await ch.assertQueue(q, { durable: true });
  await ch.prefetch(1);
  console.log(`[${name}] 待機中`);

  let n = 0;
  ch.consume(q, async (msg) => {
    if (!msg) return;
    const d = JSON.parse(msg.content.toString());
    await sleep(d.ms);
    n++;
    if (n % 25 === 0) console.log(`[${name}] ${elapsed()} 累計${n}件`);
    ch.ack(msg);
  });
}

main();

端末2・3・4で立てます。

bash
$ node burst-recv.js B1
$ node burst-recv.js B2
$ node burst-recv.js B3

端末5で、長さの監視を始めます。

bash
$ cd ~/queue-patterns && ./watch-depth.sh qp.burst

端末1で投入します。

bash
$ node burst-send.js
300件の投入にかかった時間: 41ms

端末5の出力です。

14:22:31  qp.burst = 0 件
14:22:32  qp.burst = 0 件
14:22:33  qp.burst = 287 件
14:22:34  qp.burst = 230 件
14:22:35  qp.burst = 173 件
14:22:36  qp.burst = 116 件
14:22:37  qp.burst = 59 件
14:22:38  qp.burst = 2 件
14:22:39  qp.burst = 0 件
14:22:40  qp.burst = 0 件

投入は41ミリ秒。処理には約5.5秒。 山ができて、一定の速さで引いていきました。 1秒あたり約57件ずつ減っています。

この数字が何を意味するか

もしキューが無かったら、こうなっていました。

キューありキューなし(同期処理)
同時に走る処理常に3つ(ワーカーの数)300(リクエストの数だけ)
必要なメモリ・接続3つ分300個分
利用者の待ち時間即座に返る(202)最大5.5秒
300件が3000件になったら処理時間が10倍になるだけ。落ちない落ちる
失敗したときキューに残る。やり直せるリクエストごと消える

「1秒あたり57件」は、ワーカーの台数で決まっていて、送られてきた量では変わりません。 これが負荷平準化です。 後ろの処理は、山が来たことを知りません。

この考え方は、負荷分散とは別物です。

  • 負荷分散は、同じ瞬間の仕事を横に分ける。同時に来た量は減らない
  • 負荷平準化は、同じ仕事を時間方向に伸ばす。同時に来た量そのものを減らす

そしてキューは、待ち時間(レイテンシ)を悪くします。 即座に返るのはAPIの応答だけで、仕事が終わるまでの時間は、キューが無いときより長くなります。 レイテンシとスループットの回で見た通り、両方は同時に良くなりません。 キューはスループットと安定性を、レイテンシと引き換えに買う道具です。

山が引かないなら、台数が足りない

監視すべき数値は1つです。

キューの長さが、時間とともに戻るか。

  • 戻る(山ができて引く)→ 正常。 これがやりたかったこと
  • 戻らない(増え続ける)→ ワーカーが足りない。 キューは問題を先送りしただけ

「キューを入れたから大丈夫」は間違いです。 到着より処理が遅ければ、キューは無限に伸びて、いずれメモリを食い尽くして落ちます。

Prometheus の回で監視を作ったなら、この数字を最初のグラフにしてください。 アラートも「長さが N を超えて M 分続いたら」の1本で十分です。


⑥ 失敗した仕事をどうするか

ここまで、仕事は全部成功する前提でした。しません。

外部APIは落ちます。ディスクは埋まります。そして——壊れたデータが1件混ざります。

まず、何もしないとどうなるか

わざと失敗するワーカーを書きます。

bash
$ nano fail-send.js
const { connect } = require('./common');

async function main() {
  const { conn, ch } = await connect();
  const q = 'qp.fail';
  await ch.assertQueue(q, { durable: true });
  await ch.purgeQueue(q);

  // #2 だけ、絶対に処理できない壊れたデータ
  for (let i = 1; i <= 4; i++) {
    const body = (i === 2)
      ? JSON.stringify({ id: i, broken: true })
      : JSON.stringify({ id: i });
    ch.sendToQueue(q, Buffer.from(body), { persistent: true });
  }
  console.log('4件 投入(#2 は壊れています)');

  await ch.close();
  await conn.close();
}

main();
bash
$ nano fail-recv-bad.js
// fail-recv-bad.js — ⚠️ これは「やってはいけない」書き方です
const { connect, sleep, elapsed } = require('./common');

async function main() {
  const { ch } = await connect();
  const q = 'qp.fail';
  await ch.assertQueue(q, { durable: true });
  await ch.prefetch(1);
  console.log('待機中');

  let tries = 0;
  ch.consume(q, async (msg) => {
    if (!msg) return;
    const d = JSON.parse(msg.content.toString());
    await sleep(100);

    if (d.broken) {
      tries++;
      console.log(`${elapsed()} 失敗 #${d.id} → キューに戻す(${tries}回目)`);
      // ⚠️ 第3引数 true = キューに戻す。回数を数えていない
      ch.nack(msg, false, true);
      return;
    }

    console.log(`${elapsed()} 完了 #${d.id}`);
    ch.ack(msg);
  });
}

main();

端末2で受信、端末1で送信します。

bash
$ node fail-recv-bad.js
bash
$ node fail-send.js
待機中
0.11s 完了 #1
0.21s 失敗 #2 → キューに戻す(1回目)
0.32s 失敗 #2 → キューに戻す(2回目)
0.42s 失敗 #2 → キューに戻す(3回目)
0.53s 失敗 #2 → キューに戻す(4回目)
0.63s 失敗 #2 → キューに戻す(5回目)
(…止まりません…)

#3 と #4 は、一度も処理されていません。 1件の壊れたメッセージが、キュー全体を止めました。

Ctrl + C で止めてください。 これをポイズンメッセージ(毒メッセージ)と呼びます。

そしてこの状態は、放っておくと悪化します。 CPUを100%使い続け、ログを毎秒何千行も吐き、ディスクを埋めます。 「エラーが出ているが、システムは動いているように見える」——一番見つけにくい壊れ方です。

もう一度確かめます。

bash
$ docker compose exec rabbit rabbitmqctl list_queues -q name messages
qp.fail 3

壊れた1件と、処理されていない2件が残っています。

直す —— 回数を数えて、諦める先を作る

必要なものは2つです。

  1. リトライの回数制限。 3回試したら諦める
  2. 諦めた仕事の置き場(デッドレターキュー)。 捨てずに、あとで人が見る

RabbitMQ では、キューに x-dead-letter-exchange を付けると、nack(戻さない)されたメッセージが自動でそこへ移ります。

bash
$ nano dlq-setup.js
// dlq-setup.js — 本番キューと DLQ を作る(1回だけ実行する)
const { connect } = require('./common');

async function main() {
  const { conn, ch } = await connect();

  // --- 諦めた仕事の置き場 ---
  await ch.assertExchange('qp.dlx', 'fanout', { durable: true });
  await ch.assertQueue('qp.dead', { durable: true });
  await ch.bindQueue('qp.dead', 'qp.dlx', '');

  // --- 本番のキュー。捨て先として qp.dlx を指定する ---
  await ch.assertQueue('qp.job', {
    durable: true,
    arguments: {
      'x-dead-letter-exchange': 'qp.dlx',
    },
  });

  console.log('qp.job と qp.dead を作りました');
  await ch.close();
  await conn.close();
}

main();
bash
$ node dlq-setup.js
qp.job と qp.dead を作りました

送る側です。

bash
$ nano dlq-send.js
const { connect } = require('./common');

async function main() {
  const { conn, ch } = await connect();
  await ch.purgeQueue('qp.job');
  await ch.purgeQueue('qp.dead');

  for (let i = 1; i <= 4; i++) {
    const body = (i === 2)
      ? JSON.stringify({ id: i, broken: true })
      : JSON.stringify({ id: i });
    ch.sendToQueue('qp.job', Buffer.from(body), {
      persistent: true,
      headers: { 'x-retry': 0 },   // ⚠️ 回数を自分で持つ
    });
  }
  console.log('4件 投入(#2 は壊れています)');

  await ch.close();
  await conn.close();
}

main();

受け取る側です。ここが本体です。

// dlq-recv.js — リトライ3回まで。超えたら DLQ へ
const { connect, sleep, elapsed } = require('./common');

const MAX_RETRY = 3;

async function main() {
  const { ch } = await connect();
  await ch.prefetch(1);
  console.log('待機中');

  ch.consume('qp.job', async (msg) => {
    if (!msg) return;
    const d = JSON.parse(msg.content.toString());
    const retry = msg.properties.headers?.['x-retry'] ?? 0;

    try {
      await sleep(100);
      if (d.broken) throw new Error('このデータは処理できません');

      console.log(`${elapsed()} 完了 #${d.id}`);
      ch.ack(msg);

    } catch (e) {
      if (retry >= MAX_RETRY) {
        // ⚠️ 第3引数 false = キューに戻さない → DLX 経由で qp.dead へ
        console.log(`${elapsed()} 諦め #${d.id}(${retry}回失敗)→ DLQ`);
        ch.nack(msg, false, false);
        return;
      }

      // 待ち時間を倍にしていく(指数バックオフ): 0.5s → 1s → 2s
      const wait = 500 * Math.pow(2, retry);
      console.log(`${elapsed()} 失敗 #${d.id}(${retry + 1}回目)→ ${wait}ms 後に再投入`);

      ch.ack(msg);   // 元のメッセージはここで確定して消す
      setTimeout(() => {
        ch.sendToQueue('qp.job', msg.content, {
          persistent: true,
          headers: { 'x-retry': retry + 1 },   // 回数を増やして入れ直す
        });
      }, wait);
    }
  });
}

main();
bash
$ nano dlq-recv.js

(上の内容を貼り付けます)

端末2で受信、端末1で送信します。

bash
$ node dlq-recv.js
bash
$ node dlq-send.js
待機中
0.11s 完了 #1
0.21s 失敗 #2(1回目)→ 500ms 後に再投入
0.32s 完了 #3
0.42s 完了 #4
0.83s 失敗 #2(2回目)→ 1000ms 後に再投入
1.94s 失敗 #2(3回目)→ 2000ms 後に再投入
4.05s 諦め #2(3回失敗)→ DLQ

#3 と #4 が、待たされずに処理されています。 壊れた1件が、他をブロックしていません。 そして #2 は4.05秒で諦められ、消えずに残っています。

確認します。

bash
$ docker compose exec rabbit rabbitmqctl list_queues -q name messages
qp.job  0
qp.dead 1

DLQ の中身を、消さずに覗きます。

bash
$ docker compose exec rabbit rabbitmqctl list_queues -q name messages
$ docker compose exec rabbit rabbitmqadmin -u qpuser -p qppass_change_me \
    get queue=qp.dead count=1 ackmode=reject_requeue_true
+-------------+----------+---------------+---------------------------+---------------+
| routing_key | exchange | message_count |          payload          | payload_bytes |
+-------------+----------+---------------+---------------------------+---------------+
| qp.job      |          | 0             | {"id":2,"broken":true}    | 22            |
+-------------+----------+---------------+---------------------------+---------------+

ackmode=reject_requeue_true を必ず付けてください。 これが「見るだけで、キューから消さない」という指定です。 ackmode=ack_requeue_false を指定すると、覗いた瞬間に証拠が消えます。(省略したときの既定値は ack_requeue_true でキューに戻りますが、意図が読めるよう明示します)

壊れたデータの中身がそのまま残っています。 これを見て、原因を直し、直したら DLQ から元のキューへ戻します。

押さえること

守ること理由
回数制限必ず上限を決める。 3〜5回無限リトライは、1件でキュー全体を止める
待ち時間回ごとに倍にする(指数バックオフ)すぐ再試行しても、落ちている相手はまだ落ちている。しかも殺到して復旧を邪魔する
DLQキューを作る時点で一緒に作る④で見た通り、キューの引数はあとから変えられない
DLQ の監視中身が1件でも入ったら気付けるようにするDLQ は、誰も見ないなら /dev/null と同じです
リトライ前提の処理冪等にする(RESTの回)やり直しは必ず起きる。2回走っても壊れない作りが前提

そもそもリトライしてはいけない失敗があります。 「相手が落ちている」は、時間が経てば直ります。リトライする価値があります。 「データが壊れている」「権限が無い」は、何回やっても直りません。 これは1回目で DLQ へ送ります。

見分け方は簡単です。同じ入力で、時間だけ変えたら成功しうるか。 しないなら、リトライは無駄です。

リトライを重ねても相手が復旧しないなら、そもそも呼ぶのをやめるという判断もあります。それがサーキットブレーカの回でやったことです。リトライとサーキットブレーカは、セットで考えるものです。

DLQ にも x-dead-letter-exchange を付けない

よくある事故です。 DLQ に捨て先を設定すると、DLQ で失敗したものが別のキューへ行き、そこでも失敗して…と輪になります。DLQ は終点です。 何も設定しません。


⑦ 順序が要る場合

③でワーカーを4台に増やしました。そのとき、黙って捨てたものがあります。

順序が壊れるところを見る

bench-send.js を使って、ワーカー2台で受け、番号の並びを見ます。

端末2・端末3:

bash
$ node bench-recv.js W1 1
$ node bench-recv.js W2 1

端末1:

bash
$ node bench-send.js

2つの端末の出力を、時刻順に並べるとこうなります。

0.11s [W2] 完了 #2
0.11s [W1] 完了 #1
0.21s [W2] 完了 #4
1.11s [W1] 完了 #3      ← #4 より後に終わった
1.21s [W1] 完了 #5
...

#3 は #4 より先に送られたのに、後に終わりました。 重い仕事を引いたワーカーが遅れると、順番は入れ替わります。

ワーカー1台なら順序は守られます。2台にした瞬間、保証は消えます。 これは RabbitMQ の設定で直せるものではありません。並列にするとは、そういうことです。

順序が本当に要るか、先に疑う

「順番通りに処理してほしい」の大半は、実は「結果が正しければいい」です。

要求本当に順序が要るか
「メールが登録順に届いてほしい」要らないことが多い。 数秒の前後は誰も気にしない
「同じ商品の在庫を、2つの注文が同時に減らす」順序ではなく排他制御の問題。 キューでは解けない
「同じ利用者の『住所変更』→『発送』を、逆にしてはいけない」要る。 これが本物の順序要求

「順序が要る」と言われたら、まず「どの2件の間で」を聞いてください。 ほぼ必ず、「同じ何かに属する2件」という答えが返ってきます。全体の順序が要ることは、まずありません。

逃げ道は2つしかない

① 1本にする(ワーカー1台)

[ キュー ] ── ワーカー ×1 (prefetch=1)
  • 確実。設定も要らない
  • 速くできない。 ③でやった増設が一切効かなくなる
  • 1台落ちたら止まる

② キーで分ける

「同じ利用者の中では順序が要る、利用者が違えば要らない」なら、利用者ごとにキューを分けます。

                     ┌─ [ qp.order.0 ] ── ワーカー1  ← user 3, 6, 9 …
publisher ──> 振り分け├─ [ qp.order.1 ] ── ワーカー2  ← user 1, 4, 7 …
                     └─ [ qp.order.2 ] ── ワーカー3  ← user 2, 5, 8 …

振り分けは「利用者IDを3で割った余り」のような、必ず同じ答えになる計算です。

// 同じ userId は、必ず同じキューへ行く
function queueFor(userId, n = 3) {
  let h = 0;
  for (const c of String(userId)) h = (h * 31 + c.charCodeAt(0)) % 100000;
  return `qp.order.${h % n}`;
}
  • 順序を守りながら、n台まで並列にできる
  • キューの数を変えると、振り分け先が変わって順序が壊れる。 増やすときは止めるしかない
  • 偏る。 極端に注文の多い利用者がいると、その1本だけ詰まる

これは Kafka のパーティションとまったく同じ発想です。 Kafka はこれを組み込みでやってくれます。RabbitMQ で②をやるくらいなら、Kafka を検討する目安と考えて構いません。


⑧ 他の型を、1行ずつ

ここまでの4つ(分担 / Pub-Sub / 優先度 / DLQ)が骨格です。 残りは、それらの組み合わせです。名前だけ知っておくと、必要になったときに探せます。

型何をするかRabbitMQ でのやり方
遅延キュー(delay queue)「30分後に処理してほしい」を実現する。 決済の督促、カート放棄メールなどメッセージTTL + DLX。 30分で期限切れになる待機用キューを作り、その捨て先を本番キューにする
スケジュール実行「毎日3時に」のような定時実行。 遅延キューとは別物キューの仕事ではありません。 cron / systemd timer の役目。cron が「メッセージを1件入れる」までをやる
ファンアウト(fan-out)1件の依頼を、n件の小さな仕事に割って全部投げる。 「1000人に通知」を1000件にする②の Pub/Sub とは別の意味の言葉です。 ワーカーが sendToQueue をループするだけ
リクエスト・リプライキュー越しに「返事」をもらう。 実質、非同期のRPC返信用キューを replyTo プロパティで指定し、correlationId で紐付ける
クレームチェック大きいデータ(画像・動画)をキューに入れない。 置き場のURLだけ入れるS3などに置いて、メッセージにはキーだけを入れる
べき等コンシューマ同じメッセージが2回来ても壊れないようにするメッセージIDを Redis やDBに記録し、既にあればスキップ。本線の回でやりました

「ファンアウト」という言葉は、2つの意味で使われます。

  1. RabbitMQ の fanout エクスチェンジ(②でやった、全員に同じものを配る)
  2. 1件の依頼を、たくさんの仕事に分解して投げる(バッチ処理でよく使う)

文脈で判断するしかありません。 会話で出てきたら、「エクスチェンジの話ですか、仕事を割る話ですか」と聞いてください。

クレームチェックだけは、覚えておく価値があります。

メッセージの中に、画像のバイト列を入れないでください。 メモリを食い、リトライのたびに転送し直し、DLQ に溜まったときに真っ先に壊れます。 入れるのは「どこにあるか」だけです。 数百バイトで済みます。


⑨ キューを使わない、という選択

ここまで長く書きましたが、一番大事なのはこの節です。

すぐ終わるなら、そのまま処理する

キューを入れると、こうなります。

  • プロセスが1つ増える(ワーカー)。落ちても気付きにくい
  • ブローカーが1つ増える(RabbitMQ)。これが落ちると全部止まる
  • ack と再配送を考える必要が出る → 全部の処理を冪等にする必要が出る
  • 失敗が利用者に見えなくなる。 DLQ を見に行く運用が必要になる
  • デバッグが「ログを2箇所で突き合わせる」作業になる

200ミリ秒で終わる処理を、これと引き換えにキューへ逃がす価値はありません。

目安: 利用者を待たせる時間が1秒を超えるか。 超えないなら、そのまま同期でやります。 システム設計の考え方の回で書いた通り、構成要素を増やす判断には、必ず理由が要ります。

データベースをキュー代わりにする

「1秒は超えるが、RabbitMQ を運用したくない」——この間に、選択肢があります。

CREATE TABLE jobs (
  id       BIGINT AUTO_INCREMENT PRIMARY KEY,
  payload  JSON NOT NULL,
  status   VARCHAR(16) NOT NULL DEFAULT 'pending',
  retries  INT NOT NULL DEFAULT 0,
  run_at   DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
  INDEX idx_pick (status, run_at)
);

取り出すときは、SKIP LOCKED を使います。

START TRANSACTION;
SELECT id, payload FROM jobs
 WHERE status = 'pending' AND run_at <= NOW()
 ORDER BY id
 LIMIT 1
 FOR UPDATE SKIP LOCKED;
-- 取れた id を processing に更新して COMMIT

SKIP LOCKED は「他の人が押さえている行は飛ばして、自分の分を取る」という指定です。 これが無いと、ワーカーを2台にした瞬間に、同じ行を2人が取ります。 詳しくは 同じSELECTが2回目で変わる — SQL深掘り の最後の節でやりました。

この方法の良いところは、圧倒的です。

データベースをキューにする専用のブローカー
増える構成要素ゼロブローカー1つ
トランザクション本体のデータ更新と同じトランザクションに入れられる入れられない。 「DBは更新できたがキューには入らなかった」が起きる
中身を見るSELECT するだけ管理画面か専用コマンド
リトライ・DLQretries 列と status='dead' だけ設定が要る
限界毎秒 数百件くらいまで毎秒 数万件
Pub/Sub向いていない得意

「DBの更新とキューへの投入を、両方成功させる」は、専用ブローカーでは意外と難しい問題です。 DBをキューにすれば、その問題自体が消えます。 同じトランザクションに入るからです。

毎秒数百件を超えるまでは、DBキューで足ります。 そして個人のサービスが毎秒数百件に達することは、まずありません。

判断の順番

待たせる時間は1秒未満? ──はい──> そのまま同期でやる
        │いいえ
        ↓
毎秒 数百件を超える?   ──いいえ─> DBをキューにする(SKIP LOCKED)
        │はい
        ↓
出来事を複数の受け手に配る? ─はい─> ブローカー(Pub/Sub が要る)
        │いいえ
        ↓
        ブローカー(分担が要る)

この記事で作ったものを全部使う日は、たぶん来ません。 それでいいです。 大事なのは「キューを1本立てる」で終わらせないこと——冒頭のメールが20分遅れた理由が、キューの型を選んでいなかったことだと分かることです。


つまずいたところ

遠回りしたところを、そのまま残します。

1. Pub/Sub のつもりが、分担になっていた

最初、qp.events という名前のキューを1本作って、購読者2つをそこに繋ぎました。 通知が半分ずつにしか届きません。 バグを疑ってワーカーのコードを1時間読みました。

原因は「キューが1本しかなかった」ことでした。 RabbitMQ ではキューが複製の単位です。受け手ごとにキューを作らないと、Pub/Sub になりません。

「エクスチェンジに繋げば配られる」ではありません。「エクスチェンジに、自分のキューを繋げば配られる」です。

2. prefetch を「性能チューニング」だと思っていた

「あとで最適化するときに触るもの」だと思って、無設定のまま2台に増やしました。 処理時間がほぼ変わらず、「RabbitMQ が遅いのでは」と疑いました。

性能の問題ではなく、仕事の配られ方の問題でした。 ③で見た通り、無設定の prefetch は「配り切り」を意味します。

prefetch は最適化ではなく、正しく動かすための設定です。 最初から書きます。

3. 優先度キューが「効かない」と思った

優先度を付けたのに、急ぎが最後に処理されました。 x-max-priority の値を 10 → 255 に上げてみたり、priority を 9 → 255 にしたりしました。何も変わりません。

原因は prefetch が大きかったことでした。 ワーカーが先に全部引き取ってしまえば、キューの中に並び替える相手が残りません。

優先度キューと大きな prefetch は、同時に使えません。

4. x-max-priority を、あとから足そうとした

動いているキューに優先度を足そうとして 406 PRECONDITION_FAILED を食らいました。 「引数を変えるにはキューを消すしかない」=「中の仕事を捨てるしかない」と気付いたのは、そのあとです。

この記事で qp.job を作るとき、まだ何も失敗していないのに x-dead-letter-exchange を先に付けたのは、これが理由です。

5. DLQ の中身を、覗いた瞬間に消した

rabbitmqadmin get を、どこかからコピーした ackmode=ack_requeue_false 付きで打ちました。 「取り出して ack する」指定なので、取り出した瞬間にキューから消えます。(ackmode を省いたときの既定値は ack_requeue_true で、消えません)

唯一の証拠を消しました。 再現するのに、また同じ壊れたデータを作り直しました。

DLQ を覗くときは、必ず ackmode=reject_requeue_true を付けます。

6. リトライを nack(msg, false, true) でやっていた

キューに戻す方式は、書くのは一番簡単です。 ですが回数を数える場所がありません。 メッセージの redelivered フラグは「2回目以降かどうか」しか分からず、「何回目か」は分かりません。

結果、⑥の最初でやった無限ループになりました。 回数を自分でヘッダに持って、ack して入れ直す方式に変えて解決しました。

RabbitMQ の quorum queue には x-delivery-limit という組み込みの上限があります。 使えるならそちらのほうが確実です。この記事の classic queue には無いので、自分で数えました。

7. docker compose exec のたびにキュー名が見つからない

rabbitmqctl list_queues を docker compose exec で打つと、対話用の端末を割り当てようとして出力が崩れました。 -T を付けると直ります(docker compose exec -T rabbit ...)。スクリプトの中では必ず -T を付けます。


後片づけ

RabbitMQ はメモリを食います。必ず消してください。

1. ワーカーを全部止める

端末2〜端末5を確認し、動いているものは Ctrl + C で止めます。

取りこぼしがないか、確かめます。

bash
$ ps aux | grep -E 'node (work|pubsub|bench|prio|starve|burst|fail|dlq)' | grep -v grep

何も出なければ全部止まっています。 残っていたら、表示された PID に対して:

bash
$ kill <PID>

2. キューの中身を確認してから消す

bash
$ cd ~/queue-patterns
$ docker compose exec -T rabbit rabbitmqctl list_queues -q name messages
qp.work    0
qp.bench   0
qp.prio    0
qp.starve  0
qp.burst   0
qp.fail    3
qp.job     0
qp.dead    1
qp.order.0 0

qp.fail に3件、qp.dead に1件残っています。 これは練習のゴミなので、そのまま消して構いません。

3. コンテナとデータを消す

bash
$ docker compose down -v
[+] Running 2/2
 ✔ Container qp-rabbit  Removed
 ✔ Network queue-patterns_default  Removed

-v を付けているので、キューの中身ごと消えます。

消えたことを確かめます。

bash
$ docker ps -a | grep qp-rabbit

何も出なければ成功です。

4. ポートが空いたことを確かめる

bash
$ ss -ltnp | grep -E '5672|15672'

何も出なければ正解です。

5. イメージも消す(任意)

RabbitMQ のイメージは 250MB ほどあります。 もう使わないなら消します。

bash
$ docker images | grep rabbitmq
$ docker rmi rabbitmq:3.13-management

本線の回で作った環境でも同じイメージを使っています。 そちらをまた使うなら、残しておいてください。

6. 作業ディレクトリを消す(任意)

あとで読み返す予定が無ければ消します。

bash
$ cd ~
$ rm -rf ~/queue-patterns

rm -rf は戻せません。 パスを2回読んでから打ってください。

7. 最後の確認

bash
$ docker ps
$ free -h

docker ps に qp-rabbit が無く、メモリが元に戻っていれば完了です。


まとめ — 理解できたこと

  • キューには型がある。 「1本立てて非同期にする」で終わらせると、5分の仕事の後ろで1秒の仕事が待つ。冒頭の20分は、型を選ばなかった結果だった
  • 「仕事を配る」と「出来事を知らせる」は別物。 違いはキューが何本あるか。RabbitMQ ではキューが複製の単位で、1本に2人繋いでも配られず、取り合いになる
  • メッセージの名前が、型を決める。 動詞(send_mail)なら分担、過去形の名詞(user.registered)なら Pub/Sub。出来事に動詞の名前を付けると、購読者が増えた日にメールが3通届く
  • prefetch は最適化ではなく、正しく動かすための設定。 未設定は「無制限=配り切り」で、ワーカーを2台にしても 7.4秒 → 6.7秒 にしかならなかった。1にしたら 3.8秒、4台で 2.1秒
  • 優先度キューは、prefetch が大きいと効かない。 並び替えられるのはキューの中で待っている分だけ。ワーカーの手元に渡ったものは、もう並ばない
  • 優先度は飢餓を生む。 急ぎが流れ続けている間、優先度0の仕事は一度も動かなかった。しかもエラーにならない。対策は「優先度を細かくする」ではなく、キューを分けて専用のワーカーを割り当てること
  • キューの引数は、あとから変えられない(406 PRECONDITION_FAILED)。だから DLQ と優先度は、キューを作る時点で決める
  • キューの効き目は「速くすること」ではなく「波を平らにすること」。 41ミリ秒で来た300件を、常に3並列で5.5秒かけて捌いた。同時に走る処理の数が、送られてきた量で変わらないのが要点
  • その代わり、1件が終わるまでの時間は延びる。 キューはスループットと安定性を、レイテンシと引き換えに買う道具
  • 監視すべき数値は「キューの長さが戻るか」の1つ。 戻らないならワーカーが足りず、キューは問題を先送りしただけ
  • 回数制限の無いリトライは、1件でキュー全体を止める。 実際に #3 と #4 は一度も処理されなかった。回数を数えて、諦める先(DLQ)を用意する
  • リトライしていい失敗と、してはいけない失敗がある。 見分け方は「同じ入力で、時間だけ変えたら成功しうるか」
  • ワーカーを2台にした瞬間、順序の保証は消える。 取り戻す道は1本にするかキーで分けるかの2つだけ。後者は Kafka のパーティションと同じ発想
  • そして、たいていはキューを使わないほうが正しい。 1秒未満なら同期、毎秒数百件までなら SKIP LOCKED でデータベースをキューにする。構成要素が1つも増えず、本体の更新と同じトランザクションに入れられる

参考リンク


次に読む

この記事は 【深掘り】システム設計 の 8 / 17 本目です。

記事
← 前の記事非同期処理とジョブキュー — 1つの遅い処理が全部を止める
→ 次の記事結果整合性とCAP定理 — リロードしたら件数が減った

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

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

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

System Design›System Design — Message Queues
  • 競合するコンシューマと Pub/Sub
  • 優先度キュー・平準化・デッドレター

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

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

コメント

コメントする

目次