イベント駆動アーキテクチャ — 機能を足すたび注文APIが壊れる

イベント駆動アーキテクチャ。イベントの通知カードと独立したメール、在庫、集計の小さな装置。

前に立てた Redis や MySQL が動いたままなら、先に止めてください。 この記事では専用のものを立て直します(同じポートを使います)。

前回: データストアの選び方 — 速いのはJOINをしていないから

これは【深掘り】の記事です。本線の順路ではありません。 読まなくても先へ進めます。 本線のまだマイクロサービスにしない — モノリスと12 Factorの回で、「分ける前に、分ける理由を作れ」という話をしました。この記事はその「理由」のほうを扱います。 サービスを物理的に分けなくても、呼び出しの形だけをイベントに替えるとどうなるか。得るものと、失うものを両方測ります。

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

前提: VMに Docker と Docker Compose が入っていて、node -v と npm -v が返ること。 端末を最大5つ開きます。 VS Code の統合ターミナルでも、ssh を5本張っても構いません。この記事では「端末1」「端末2」…と呼びます。

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

目次

それが無いと、何が困ったか

作っていたのは、ごく普通の注文APIです。POST /orders を叩くと、注文が保存される。それだけでした。

そこに、要望が順番に増えていきました。

  1. 注文したら確認メールを送ってほしい
  2. 注文したら在庫を減らしてほしい
  3. 注文したらその日の売上集計を更新してほしい

私は素直に書きました。注文APIの中で、3つの関数を順に呼びます。

await saveOrder(order);
await sendMail(order);      // 追加した
await reduceStock(order);   // 追加した
await updateStats(order);   // 追加した
res.json({ ok: true });

動きました。 そして数日後、こうなりました。

「注文ボタンを押すと『500 Internal Server Error』が出ます。買えません」

原因を追うと、メール送信に使っていた外部サービスが落ちていました。

ここで頭が真っ白になりました。メールが送れないだけです。注文自体は保存できています。 なのに、レスポンスは500で、利用者から見ると「買えなかった」ことになっている。しかも saveOrder は成功しているので、注文は入っているのに買えなかったと思われているという、一番まずい状態でした。

さらに悪いことに、翌週こう言われます。

「注文したら Slack にも通知を出したいです」

また注文APIを開くことになります。 4つ目の await が増えます。注文とは何の関係もない機能を足すために、注文という一番壊してはいけないコードを毎回触る。 これはおかしい、と思いました。

問題は「メールが失敗したこと」ではありません。 注文APIが、注文と関係ない3つの都合を全部知っていることです。

この記事でやるのは、その形を組み替えることです。そして、組み替えた結果として何を失うのかも、同じ手数をかけて測ります。 イベント駆動は「良いもの」ではありません。代償を払って別の性質を買う取引です。

この記事でわかること

  • 直接呼ぶ形では、呼ばれる側が1つ落ちると呼ぶ側まで落ちること。それは try/catch を足しても本質的には直らないこと
  • イベント形にすると、注文APIは「起きたこと」を1本流すだけになり、機能を足しても注文APIを1行も触らなくなること
  • その代わりに、全体の流れがどのファイルにも書かれなくなること。コードを上から読んでも、何が何の順で起きるか分からないこと
  • 「コマンド」と「イベント」は別物だということ。片方は拒否できて、片方は拒否できないこと。だから名前を過去形にすること
  • 中央で指揮する形(オーケストレーション)と、各自が勝手に反応する形(コレオグラフィ)は、可読性と拡張性を取引していること
  • CQRS の効き目は「読む形をあらかじめ作っておく」ことにあり、速さは実測で桁が変わること。その代わり読み側は必ず遅れること
  • イベントソーシングは強力だが、再生の遅さ・形の変更不能・削除の困難という3つの代償があり、大半のアプリには要らないこと
  • そして、1つのアプリを1人で作っているうちは、直接呼ぶ形のほうが正しいこと

この記事でやること

  1. ~/evtlab に Redis と MySQL を Docker Compose で立て、まず「直接呼ぶ」形の注文APIを作る。メールを1つ落として、注文が500になるところを実際に見る
  2. 同じ機能を Redis Streams のイベント形に組み替える。購読側を1つ落として注文が成功し続けること、購読を1つ足して注文APIを触らずに機能が増えることを確かめる
  3. 代償を4つ測る。流れが読めない・追跡できない・結果整合になる・同じイベントが2回届く
  4. コマンドとイベントの違いを、名前と受け手の数で区別する
  5. オーケストレーションとコレオグラフィを、同じ処理の2通りの実装で比べる
  6. CQRS を作る。20万件の JOIN 集計と、イベントで更新しておいた集計テーブルの実行時間を並べる
  7. イベントソーシングを最小構成で書く。残高を再生で出し、イベントを増やして再生が遅くなるところまで見る
  8. 立てたものを全部消す

先に知る言葉

基本的な言葉は用語集にもまとめてあります。

言葉この記事での意味
イベントすでに起きた事実の記録。OrderPlaced(注文された)のように過去形で名づける。受け手は拒否できない
コマンドこれからやってほしいことの依頼。PlaceOrder(注文しろ)のように命令形。受け手は1人で、断ることができる
パブリッシュ / サブスクライブイベントを流す側と拾う側。流す側は、誰が拾うかを知らない
Redis StreamsRedis に入っている追記専用のログ。流したイベントが読んでも消えない。Kafkaの小さい版だと思ってよい
コンシューマグループStreams を読む読み手のまとまり。グループごとに読んだ位置を別々に覚えるので、同じイベントを3つのサービスがそれぞれ全部読める
結果整合「いまはまだ反映されていないが、そのうち揃う」状態。イベント形では避けられない
相関ID1回の注文に振る通し番号。ログが3つのプロセスに散っても、これで1本に繋げる
冪等同じことを2回やっても結果が変わらない性質。イベントは2回届きうるので必須
CQRS書く形と読む形を別々に持つ設計。Command Query Responsibility Segregation の略
イベントソーシング現在の状態を保存せず、起きたことを全部保存して、必要なとき再生して状態を出す方式

① まず「直接呼ぶ」形を作る

作業場所と土台を作る

端末1で打ちます。

bash
$ mkdir -p ~/evtlab && cd ~/evtlab
$ mkdir -p lib direct events ledger sql
$ npm init -y >/dev/null
$ npm i express redis mysql2
$ node -e "console.log('node ok')"

node ok が出れば準備完了です。

次に Redis と MySQL を Compose で立てます。

bash
$ cat > ~/evtlab/docker-compose.yml <<'YAML'
  services:
    redis:
      image: redis:7-alpine
      container_name: evtlab-redis
      ports:
        - "127.0.0.1:6379:6379"
    mysql:
      image: mysql:8.4
      container_name: evtlab-mysql
      environment:
        MYSQL_ROOT_PASSWORD: evtlab
        MYSQL_DATABASE: evtlab
      ports:
        - "127.0.0.1:3306:3306"
      command: --local-infile=0
  YAML
$ cd ~/evtlab && docker compose up -d

ポートを 127.0.0.1: に縛っているのは意図的です。 これを書かないと、VMの外からも 3306 が開きます。学習用でも開けっぱなしにしません。

MySQL は起動に30秒ほどかかります。待つのではなく、返るまで確かめます。

bash
$ until docker exec evtlab-mysql mysqladmin ping -uroot -pevtlab --silent 2>/dev/null; do echo "waiting..."; sleep 2; done; echo "mysql ready"

mysql ready が出たら次へ進みます。

📷 スクリーンショット: docker compose ps の出力で、evtlab-redis と evtlab-mysql の2つが running になっているところ。

表を作る

bash
$ cat > ~/evtlab/sql/schema.sql <<'SQL'
  DROP TABLE IF EXISTS mail_log;
  DROP TABLE IF EXISTS orders;
  DROP TABLE IF EXISTS products;
  DROP TABLE IF EXISTS daily_sales;
  DROP TABLE IF EXISTS processed_events;
  
  CREATE TABLE products (
    id INT PRIMARY KEY,
    name VARCHAR(50) NOT NULL,
    price INT NOT NULL,
    stock INT NOT NULL
  );
  
  CREATE TABLE orders (
    id VARCHAR(40) PRIMARY KEY,
    email VARCHAR(120) NOT NULL,
    product_id INT NOT NULL,
    qty INT NOT NULL,
    created_at DATETIME NOT NULL,
    INDEX idx_created (created_at)
  );
  
  CREATE TABLE mail_log (
    id INT AUTO_INCREMENT PRIMARY KEY,
    order_id VARCHAR(40) NOT NULL,
    sent_at DATETIME NOT NULL
  );
  
  CREATE TABLE daily_sales (
    day DATE PRIMARY KEY,
    order_count INT NOT NULL DEFAULT 0,
    amount BIGINT NOT NULL DEFAULT 0
  );
  
  CREATE TABLE processed_events (
    consumer VARCHAR(40) NOT NULL,
    event_id VARCHAR(40) NOT NULL,
    PRIMARY KEY (consumer, event_id)
  );
  
  INSERT INTO products (id, name, price, stock) VALUES
    (1, 'キーボード', 8000, 100),
    (2, 'マウス',     3000, 100),
    (3, 'モニタ',    24000, 100);
  SQL
$ docker exec -i evtlab-mysql mysql -uroot -pevtlab evtlab < ~/evtlab/sql/schema.sql
$ docker exec -i evtlab-mysql mysql -uroot -pevtlab evtlab -e "SELECT * FROM products;"

商品3件が表示されれば成功です。

3つの処理を書く

bash
$ cat > ~/evtlab/lib/db.js <<'JS'
  const mysql = require('mysql2/promise');
  const pool = mysql.createPool({
    host: '127.0.0.1', port: 3306,
    user: 'root', password: 'evtlab', database: 'evtlab',
    connectionLimit: 10,
  });
  module.exports = { pool };
  JS

$ cat > ~/evtlab/lib/handlers.js <<'JS'
  const { pool } = require('./db');
  
  // ① メール送信(外部サービスに繋ぐつもりのもの)
  async function sendMail(order) {
    if (process.env.MAIL_BROKEN === '1') {
      throw new Error('メールサーバーに繋がりません');
    }
    await new Promise(r => setTimeout(r, 200));   // 外部APIの往復のつもり
    await pool.query(
      'INSERT INTO mail_log (order_id, sent_at) VALUES (?, NOW())', [order.id]
    );
    console.log(`[mail ] 送信 order=${order.id} to=${order.email}`);
  }
  
  // ② 在庫を減らす
  async function reduceStock(order) {
    await pool.query(
      'UPDATE products SET stock = stock - ? WHERE id = ?', [order.qty, order.productId]
    );
    console.log(`[stock] 減算 order=${order.id} product=${order.productId} qty=${order.qty}`);
  }
  
  // ③ 売上集計を更新する
  async function updateStats(order) {
    const [[p]] = await pool.query('SELECT price FROM products WHERE id = ?', [order.productId]);
    const amount = p.price * order.qty;
    await pool.query(
      `INSERT INTO daily_sales (day, order_count, amount) VALUES (CURDATE(), 1, ?) AS new
       ON DUPLICATE KEY UPDATE order_count = order_count + 1, amount = amount + new.amount`,
      [amount]
    );
    console.log(`[stats] 集計 order=${order.id} amount=${amount}`);
  }
  
  module.exports = { sendMail, reduceStock, updateStats };
  JS

直接呼ぶ注文APIを書く

bash
$ cat > ~/evtlab/direct/server.js <<'JS'
  const express = require('express');
  const crypto = require('crypto');
  const { pool } = require('../lib/db');
  const { sendMail, reduceStock, updateStats } = require('../lib/handlers');
  
  const app = express();
  app.use(express.json());
  
  app.post('/orders', async (req, res) => {
    const order = {
      id: crypto.randomUUID().slice(0, 8),
      email: req.body.email,
      productId: req.body.productId,
      qty: req.body.qty,
    };
    const t0 = Date.now();
    try {
      await pool.query(
        'INSERT INTO orders (id, email, product_id, qty, created_at) VALUES (?,?,?,?,NOW())',
        [order.id, order.email, order.productId, order.qty]
      );
      await sendMail(order);       // ← 足した
      await reduceStock(order);    // ← 足した
      await updateStats(order);    // ← 足した
      res.json({ ok: true, id: order.id, ms: Date.now() - t0 });
    } catch (e) {
      console.error('[api  ] 失敗:', e.message);
      res.status(500).json({ ok: false, error: e.message });
    }
  });
  
  app.listen(3000, () => console.log('direct api on :3000'));
  JS

端末2で起動します。

bash
$ cd ~/evtlab && node direct/server.js

端末1に戻って叩きます。

bash
$ curl -s -X POST localhost:3000/orders \
    -H 'content-type: application/json' \
    -d '{"email":"a@example.com","productId":1,"qty":2}'

こう返ります。

{"ok":true,"id":"3f9c1a2b","ms":214}

動いています。 在庫も減っています。

bash
$ docker exec -i evtlab-mysql mysql -uroot -pevtlab evtlab -e "SELECT id,name,stock FROM products; SELECT * FROM daily_sales;"

メールを1つ落とす

ここが本題です。端末2で Ctrl+C して、メールだけを壊した状態で立て直します。

bash
$ cd ~/evtlab && MAIL_BROKEN=1 node direct/server.js

端末1でもう一度注文します。

bash
$ curl -s -o /dev/null -w '%{http_code}\n' -X POST localhost:3000/orders \
    -H 'content-type: application/json' \
    -d '{"email":"b@example.com","productId":1,"qty":1}'
500

メールが送れないだけで、注文APIが500を返しました。

しかも、より悪いことが起きています。注文は保存されています。在庫は減っていません。

bash
$ docker exec -i evtlab-mysql mysql -uroot -pevtlab evtlab \
    -e "SELECT id,email FROM orders; SELECT id,name,stock FROM products;"

b@example.com の注文が orders に入っているのに、在庫は減っていません。sendMail が例外を投げた時点で、reduceStock も updateStats も実行されていないからです。

これは「メールの障害」ではなく「データの不整合」です。 注文は存在するのに在庫は減っていない。あとで人が手で直すことになります。

直接呼ぶ形の本当の問題は、失敗が伝播することではありません。 「一部だけ実行された」状態が、そこら中に作れてしまうことです。

「じゃあ try/catch で囲めばいい」と思いますよね。私もそうしました。

try { await sendMail(order); } catch (e) { console.error(e); }

これで500は出なくなります。 でも直っていません。

  • 失敗したメールは、どこにも残らず消えます。 再送する手段がありません
  • 注文APIは相変わらず3つの関数を知っています。 Slack通知を足せば、また開くことになります
  • catch を書き忘れた4つ目が入った瞬間、元に戻ります

必要なのは「エラーを握りつぶすこと」ではなく、「注文APIが3つの都合を知らないこと」です。

端末2は Ctrl+C で止めておきます。


② イベント形に組み替える

何を変えるか

やることは1つだけです。注文APIは OrderPlaced(注文された)というイベントを1本流して終わりにします。3つの処理は、それぞれ別のプロセスでそのイベントを拾います。

【前】 注文API ──▶ sendMail ──▶ reduceStock ──▶ updateStats
                (1つ落ちると、そこで止まる)

【後】 注文API ──▶ [ orders ストリーム ]
                        │
                        ├──▶ mail   (落ちても注文は通る)
                        ├──▶ stock
                        └──▶ stats

注文APIは、誰が拾うかを知りません。 これが決定的な違いです。

流す側を書く

Redis の Streams を使います。本線の Redis の回で触ったキャッシュとは別の機能で、追記専用のログです。

bash
$ cat > ~/evtlab/lib/bus.js <<'JS'
  const { createClient } = require('redis');
  const STREAM = 'orders';
  
  async function connect() {
    const c = createClient({ url: 'redis://127.0.0.1:6379' });
    c.on('error', e => console.error('[redis]', e.message));
    await c.connect();
    return c;
  }
  
  // イベントを流す
  async function publish(client, type, payload, correlationId) {
    return client.xAdd(STREAM, '*', {
      type,
      correlationId,
      data: JSON.stringify(payload),
    });
  }
  
  // イベントを拾い続ける
  async function subscribe(group, consumerName, handler) {
    const c = await connect();
    try {
      await c.xGroupCreate(STREAM, group, '0', { MKSTREAM: true });
    } catch (e) {
      if (!String(e.message).includes('BUSYGROUP')) throw e;
    }
    console.log(`[${group}] 購読開始`);
  
    // まず自分が受け取ったまま ack していない分(保留分)を先に処理する
    let cursor = '0';
    for (;;) {
      const res = await c.xReadGroup(
        group, consumerName,
        [{ key: STREAM, id: cursor }],
        { COUNT: 10, BLOCK: 5000 }
      );
      if (!res) { cursor = '>'; continue; }
      for (const stream of res) {
        if (stream.messages.length === 0) { cursor = '>'; continue; }
        for (const m of stream.messages) {
          await handler({
            eventId: m.id,
            type: m.message.type,
            correlationId: m.message.correlationId,
            payload: JSON.parse(m.message.data),
          });
          await c.xAck(STREAM, group, m.id);
        }
      }
    }
  }
  
  module.exports = { STREAM, connect, publish, subscribe };
  JS

xGroupCreate の第3引数 '0' と MKSTREAM が要点です。 ストリームがまだ無ければ作り、先頭から読むという意味です。これを '$'(今以降)にすると、購読を後から足したとき、過去のイベントが1件も届きません。

注文APIはこうなります。

bash
$ cat > ~/evtlab/events/api.js <<'JS'
  const express = require('express');
  const crypto = require('crypto');
  const { pool } = require('../lib/db');
  const { connect, publish } = require('../lib/bus');
  
  (async () => {
    const redis = await connect();
    const app = express();
    app.use(express.json());
  
    app.post('/orders', async (req, res) => {
      const t0 = Date.now();
      const order = {
        id: crypto.randomUUID().slice(0, 8),
        email: req.body.email,
        productId: req.body.productId,
        qty: req.body.qty,
      };
      const correlationId = crypto.randomUUID().slice(0, 8);
      try {
        await pool.query(
          'INSERT INTO orders (id, email, product_id, qty, created_at) VALUES (?,?,?,?,NOW())',
          [order.id, order.email, order.productId, order.qty]
        );
        const eventId = await publish(redis, 'OrderPlaced', order, correlationId);
        console.log(`[api  ] cid=${correlationId} OrderPlaced=${eventId} order=${order.id}`);
        res.json({ ok: true, id: order.id, correlationId, ms: Date.now() - t0 });
      } catch (e) {
        console.error('[api  ] 失敗:', e.message);
        res.status(500).json({ ok: false, error: e.message });
      }
    });
  
    app.listen(3000, () => console.log('event api on :3000'));
  })();
  JS

注文APIから sendMail も reduceStock も updateStats も消えました。 require すらしていません。注文APIは、この3つの存在を知りません。

拾う側を3つ書く

bash
$ cat > ~/evtlab/events/sub-mail.js <<'JS'
  const { subscribe } = require('../lib/bus');
  const { sendMail } = require('../lib/handlers');
  subscribe('mail', 'c1', async (ev) => {
    if (ev.type !== 'OrderPlaced') return;
    console.log(`[mail ] cid=${ev.correlationId} 受信 ${ev.eventId}`);
    await sendMail(ev.payload);
  });
  JS

$ cat > ~/evtlab/events/sub-stock.js <<'JS'
  const { subscribe } = require('../lib/bus');
  const { reduceStock } = require('../lib/handlers');
  subscribe('stock', 'c1', async (ev) => {
    if (ev.type !== 'OrderPlaced') return;
    console.log(`[stock] cid=${ev.correlationId} 受信 ${ev.eventId}`);
    await reduceStock(ev.payload);
  });
  JS

$ cat > ~/evtlab/events/sub-stats.js <<'JS'
  const { subscribe } = require('../lib/bus');
  const { updateStats } = require('../lib/handlers');
  subscribe('stats', 'c1', async (ev) => {
    if (ev.type !== 'OrderPlaced') return;
    console.log(`[stats] cid=${ev.correlationId} 受信 ${ev.eventId}`);
    await updateStats(ev.payload);
  });
  JS

グループ名が3つとも違うのが要点です。グループが違えば、読んだ位置は別々に管理されます。 だから同じ OrderPlaced を3つとも全部受け取ります。逆に同じグループ名で2つ起動すると、イベントは分担され、片方にしか届きません(前回やった競合するコンシューマの形です)。

動かす

端末を4つ使います。

端末コマンド
端末2cd ~/evtlab && node events/api.js
端末3cd ~/evtlab && node events/sub-mail.js
端末4cd ~/evtlab && node events/sub-stock.js
端末5cd ~/evtlab && node events/sub-stats.js

端末1で注文します。

bash
$ curl -s -X POST localhost:3000/orders -H 'content-type: application/json' \
    -d '{"email":"c@example.com","productId":2,"qty":3}'
{"ok":true,"id":"a71d0e55","correlationId":"9b2c4d10","ms":6}

ms が 214 から 6 に落ちました。 メール送信の200msを待たなくなったからです。

端末3・4・5に、それぞれ1行ずつログが出ているはずです。

📷 スクリーンショット: 端末を4分割して、左上に注文API、右上にmail、左下にstock、右下にstats のログが同じ cid= で並んで出ているところ。

購読を1つ落としてみる

端末3(mail)だけ Ctrl+C で落とします。 そして注文します。

bash
$ curl -s -o /dev/null -w '%{http_code}\n' -X POST localhost:3000/orders \
    -H 'content-type: application/json' -d '{"email":"d@example.com","productId":2,"qty":1}'
200

メール担当が完全に落ちているのに、注文は成功しました。 在庫も集計も動いています。

しかも、これが Streams の効き目です。端末3を立て直します。

bash
$ cd ~/evtlab && node events/sub-mail.js

落ちている間に流れた注文のメールが、いま送られます。 イベントは読んでも消えないので、復旧した時点で追いつけます。ここは Kafka の回でやった「オフセット」と同じ考え方です。

機能を1つ足してみる

「Slack にも通知したい」という例の要望です。注文APIは触りません。

bash
$ cat > ~/evtlab/events/sub-slack.js <<'JS'
  const { subscribe } = require('../lib/bus');
  subscribe('slack', 'c1', async (ev) => {
    if (ev.type !== 'OrderPlaced') return;
    console.log(`[slack] cid=${ev.correlationId} 通知: 注文 ${ev.payload.id} が入りました`);
  });
  JS

端末3をもう1つ増やすか、いま空いている端末で起動します。

bash
$ cd ~/evtlab && node events/sub-slack.js

起動した瞬間、これまでの注文が全部流れてきます。 xGroupCreate を '0' で作ったので、新しいグループは先頭から読むからです。

bash
$ git -C ~/evtlab status 2>/dev/null || true
$ ls -l ~/evtlab/events

変更したファイルは1つもありません。追加しただけです。

これがイベント駆動で買えるものです。 「機能を足すこと」が「既存のコードを触ること」から切り離される。


③ 何を失ったかを、同じだけ測る

ここからが本題です。上の気持ちよさには、はっきりした対価があります。

代償1: 全体の流れが、どのファイルにも書かれていない

直接呼ぶ形では、direct/server.js を上から読めば全部分かりました。

await saveOrder(order);
await sendMail(order);
await reduceStock(order);
await updateStats(order);

5行読めば、注文で何が起きるか分かります。 順番も、依存も、全部そこにあります。

イベント形では、events/api.js を読んでも「OrderPlaced を流した」しか書いていません。 何が起きるかは、こう調べることになります。

bash
$ grep -rn "OrderPlaced" ~/evtlab/events
/home/user/evtlab/events/api.js:24:      const eventId = await publish(redis, 'OrderPlaced', order, correlationId);
/home/user/evtlab/events/sub-mail.js:3:  if (ev.type !== 'OrderPlaced') return;
/home/user/evtlab/events/sub-slack.js:3:  if (ev.type !== 'OrderPlaced') return;
/home/user/evtlab/events/sub-stats.js:3:  if (ev.type !== 'OrderPlaced') return;
/home/user/evtlab/events/sub-stock.js:3:  if (ev.type !== 'OrderPlaced') return;

grep しないと分からない設計になりました。 しかもこの grep は「実行順」を教えてくれません。 順番は無いからです(全部同時に走ります)。

これはファイル4つの実験だからまだ読めます。サービスが20個ある本番で同じことをすると、「注文すると何が起きるのか、社内の誰も正確には答えられない」状態になります。 私はこれを軽く見ていました。

対策は「イベントの一覧を人間が読める場所に置く」ことしかありません。コードから自動生成できないなら、ドキュメントを書く義務が増えたということです。それも代償です。

代償2: 追跡が難しい。相関IDが要る

上のコードで、私は最初から correlationId を入れておきました。入れなかった場合を再現します。

3つの端末のログを、ID無しで想像してください。

[mail ] 送信 order=a71d0e55
[stock] 減算 order=93b2f0c1
[stats] 集計 order=a71d0e55

注文が秒間100件あると、これはもう追えません。 どのログがどの注文の一部なのか、時刻でしか繋げなくなります。

相関IDがあれば、こう追えます。

bash
$ cd ~/evtlab && grep -rn "cid=9b2c4d10" *.log 2>/dev/null || echo "(ログをファイルに落としていないので、各端末を目で見る)"

実運用では、ログを1箇所に集めて相関IDで引きます。本線のログが3箇所に散っている — Lokiで1画面にすると、「遅い」の次は「どこが」 — 分散トレーシング入門は、イベント駆動にした瞬間に「あると便利」から「無いと運用できない」に変わります。

イベント駆動を入れるなら、ログ集約と相関IDは同時に入れる。 あとから足すのは非常につらい。

代償3: 結果整合になる。注文直後にメール履歴が無い

これは目で見られます。注文した直後に、メール履歴を読みます。

bash
$ curl -s -X POST localhost:3000/orders -H 'content-type: application/json' \
    -d '{"email":"e@example.com","productId":3,"qty":1}' > /tmp/last.json
$ cat /tmp/last.json
$ ID=$(node -e "console.log(require('/tmp/last.json').id)")
$ docker exec -i evtlab-mysql mysql -uroot -pevtlab evtlab \
    -e "SELECT COUNT(*) AS mails FROM mail_log WHERE order_id='$ID';"
+-------+
| mails |
+-------+
|     0 |
+-------+

0件です。 0.2秒後にもう一度読むと1件になります。

bash
$ sleep 1
$ docker exec -i evtlab-mysql mysql -uroot -pevtlab evtlab \
    -e "SELECT COUNT(*) AS mails FROM mail_log WHERE order_id='$ID';"
|     1 |

注文APIが 200 を返した時点では、メールはまだ送られていません。

直接呼ぶ形なら、200が返った時点で3つとも終わっていました。その保証を、いま失いました。

画面を作る側から見ると、これは「注文完了ページで『確認メールを送りました』と書けなくなった」という話になります。書くなら嘘になりうる。この性質は、レプリケーションの遅れと同じ形です。遅れは避けられない。設計で受け止めるしかない。

現実的な受け止め方は3つです。

やり方内容代償
文言を変える「確認メールを送ります」(未来形)にするいちばん安い。まずこれ
画面で待つ完了ページから状態をポーリングする実装が増える
その処理だけ同期に戻すメールだけ注文APIから直接呼ぶ①の問題が戻ってくる

代償4: 同じイベントが2回届く

これは仕様です。バグではありません。 実際に起こします。

端末5(stats)を Ctrl+C で止めます。 そして、ack の前で落ちる状況を作るため、わざと遅くしたハンドラを用意します。

bash
$ cat > ~/evtlab/events/sub-stats-slow.js <<'JS'
  const { subscribe } = require('../lib/bus');
  const { updateStats } = require('../lib/handlers');
  subscribe('stats', 'c1', async (ev) => {
    if (ev.type !== 'OrderPlaced') return;
    console.log(`[stats] 受信 ${ev.eventId} … 5秒かけて処理します(この間に Ctrl+C)`);
    await updateStats(ev.payload);
    await new Promise(r => setTimeout(r, 5000));   // ack までの時間を延ばす
    console.log(`[stats] 完了 ${ev.eventId}`);
  });
  JS

端末5で起動します。

bash
$ cd ~/evtlab && node events/sub-stats-slow.js

端末1で注文して、端末5に「5秒かけて処理します」が出たら、端末5を Ctrl+C で落とします。

bash
$ docker exec evtlab-redis redis-cli XPENDING orders stats
1) (integer) 1
2) "1790000000000-0"
3) "1790000000000-0"
4) 1) 1) "c1"
      2) "1"

ack していないイベントが1件、保留されています。

ここで通常の sub-stats.js を立て直します。

bash
$ cd ~/evtlab && node events/sub-stats.js
[stats] cid=... 受信 1790000000000-0
[stats] 集計 order=... amount=24000

同じイベントをもう一度処理しました。 集計を確認します。

bash
$ docker exec -i evtlab-mysql mysql -uroot -pevtlab evtlab -e "SELECT * FROM daily_sales;"

その注文の金額が2回足されています。 売上が水増しされました。

「ちょうど1回だけ届く」は、ほとんどの現実の仕組みで実現できません。 届くのは「少なくとも1回」です。だから受け手が冪等でなければなりません。

前回の記事でやった冪等の話が、ここで効いてきます。受け手側で「このイベントIDはもう処理した」を記録します。 processed_events 表を最初に作ったのはこのためです。

bash
$ cat > ~/evtlab/events/sub-stats-idem.js <<'JS'
  const { subscribe } = require('../lib/bus');
  const { updateStats } = require('../lib/handlers');
  const { pool } = require('../lib/db');
  
  subscribe('stats', 'c1', async (ev) => {
    if (ev.type !== 'OrderPlaced') return;
    const [r] = await pool.query(
      'INSERT IGNORE INTO processed_events (consumer, event_id) VALUES (?, ?)',
      ['stats', ev.eventId]
    );
    if (r.affectedRows === 0) {
      console.log(`[stats] 既に処理済み ${ev.eventId} → 何もしない`);
      return;
    }
    await updateStats(ev.payload);
  });
  JS

INSERT IGNORE の affectedRows が 0 なら、すでに処理済みということです。判定と記録を1回のSQLでやっているので、間に別のプロセスが割り込めません。 ここを SELECT してから INSERT にすると、2つのプロセスが同時に「まだ無い」と判定できてしまいます。

これで同じ手順を繰り返すと、2回目は 既に処理済み になり、金額は増えません。

イベント駆動を入れるということは、「すべての受け手に冪等の責任を配る」ということです。 受け手が10個あれば、10箇所で考えることになります。


④ コマンドとイベントを区別する

ここまで「イベント」と呼んできたものには、実は兄弟がいます。混ぜると設計が壊れます。

コマンドイベント
意味やれ(依頼)起きた(事実)
名前の形命令形。PlaceOrder SendMail過去形。OrderPlaced MailSent
受け手の数1人(誰がやるか決まっている)0人以上(誰が拾ってもいい)
拒否できるかできる(在庫不足なら断る)できない(もう起きたから)
失敗の意味依頼が通らなかった拾い損ねた(事実は残る)
送り主の関心結果を知りたい知らなくていい
向いている場所キュー(1本、競合するコンシューマ)ストリーム(複数グループ)

なぜ過去形にするのか

私は最初 SendOrderMail という名前でイベントを流していました。これは事故のもとです。

SendOrderMail という名前を見た人は、こう考えます。

  • 「送るのはメールサービスの仕事だな」→ 受け手が1人だと思い込む
  • 「じゃあ在庫のことは別のイベントを足そう」→ ReduceStock も流す
  • 結果、注文APIが「メールを送れ」「在庫を減らせ」「集計を更新しろ」と3本流す

元に戻りました。 名前が命令形だと、注文APIがまた3つの都合を知ることになります。

OrderPlaced(注文された)という名前なら、注文APIは「注文された」としか言っていません。 そのあと何が起きるかは、拾う側の都合です。

名前の形が、責任の置き場所を決めます。 命令形は「送る側が結果に責任を持つ」、過去形は「受け取る側が自分の都合に責任を持つ」。

実際にはどちらも要る

「全部イベントにする」も間違いです。注文そのものは、断れなければ困ります。

利用者 ──[ PlaceOrder(コマンド)]──▶ 注文API
                                       │ 在庫が無ければ 409 を返す ← 断れる
                                       │ 通ったら
                                       ▼
                                  [ OrderPlaced(イベント)] ──▶ 拾う側たち

外から中への入口はコマンド、中で広がるのはイベント。 この形が一番多く見ます。今回の POST /orders がまさにコマンドで、その中から OrderPlaced を流しています。


⑤ オーケストレーションとコレオグラフィ

複数の処理が順番に必要な場合、2つの組み方があります。

「注文 → 決済 → 発送手配 → 完了通知」を例にします。

オーケストレーション(中央に指揮者を置く)

bash
$ cat > ~/evtlab/events/orchestrator.js <<'JS'
  // 「注文サガ」— 全体の流れを1箇所に書く
  async function runOrderSaga(order) {
    console.log(`[saga ] 1. 決済 order=${order.id}`);
    const paid = await charge(order);
    if (!paid.ok) {
      console.log(`[saga ] 決済失敗 → 在庫を戻して終了`);
      await restoreStock(order);          // 補償(打ち消しの処理)
      return { ok: false, reason: 'payment' };
    }
    console.log(`[saga ] 2. 発送手配 order=${order.id}`);
    const ship = await requestShipping(order);
    if (!ship.ok) {
      console.log(`[saga ] 発送失敗 → 返金して在庫を戻す`);
      await refund(order);                // 補償
      await restoreStock(order);
      return { ok: false, reason: 'shipping' };
    }
    console.log(`[saga ] 3. 完了通知 order=${order.id}`);
    await notifyDone(order);
    return { ok: true };
  }
  JS

このファイルを読めば、全部分かります。 順番も、失敗したときの巻き戻し(補償)も、全部ここにあります。

コレオグラフィ(各自が反応する)

同じことを、こう書きます。

OrderPlaced      ──▶ 決済サービス   → PaymentCharged を流す
PaymentCharged   ──▶ 発送サービス   → ShipmentRequested を流す
ShipmentRequested──▶ 通知サービス   → 完了メール
PaymentFailed    ──▶ 在庫サービス   → 在庫を戻す

中央のファイルはありません。 それぞれのサービスが「自分は何を聞いて、何を叫ぶか」だけ知っています。

比べる

オーケストレーションコレオグラフィ
全体の流れ1ファイルに書いてあるどこにも書いていない
手順を足す指揮者を書き換える購読を追加するだけ
失敗時の巻き戻し指揮者が知っている。書きやすい打ち消し用のイベントを設計する。難しい
単一障害点指揮者が落ちると全部止まる落ちた1つの先だけ止まる
結合指揮者が全員を知っている(強い)誰も誰かを知らない(弱い)
向く規模手順が決まっていて、途中で分岐するもの手順が増え続けるもの

コレオグラフィは、足すのは一番楽です。そして、全体が誰にも見えなくなります。 「注文するとどのサービスが動くか」を答えられる人が、社内から消えます。

私の現在の判断はこうです。

  • お金が動く一連の流れ(決済・返金・在庫の押さえ)はオーケストレーション。巻き戻しを1箇所で見たいから
  • 付随する通知や集計はコレオグラフィ。増え続けるし、失敗しても巻き戻しが要らないから

全部をどちらかにしない。 これは全部やるか、1つもやらないか — トランザクションとACIDでやった「1つのDBならトランザクションで済む」が使えない世界の話です。サービスを跨ぐと ROLLBACK は使えません。 だから補償処理を自分で書くことになります。これも、分けたことの代償です。


⑥ CQRS — 書く形と読む形を分ける

何が問題なのか

売上の画面を作ります。「日別の注文件数と金額」です。素直に書くとこうなります。

SELECT DATE(o.created_at) AS day, COUNT(*) AS cnt, SUM(p.price * o.qty) AS amount
FROM orders o JOIN products p ON p.id = o.product_id
GROUP BY DATE(o.created_at);

注文が少ないうちは一瞬です。 増えるとどうなるか、実際に増やします。

bash
$ cat > ~/evtlab/events/seed-orders.js <<'JS'
  const { pool } = require('../lib/db');
  (async () => {
    const N = 200000, BATCH = 2000;
    console.time('seed');
    for (let i = 0; i < N; i += BATCH) {
      const rows = [];
      for (let j = 0; j < BATCH; j++) {
        const n = i + j;
        rows.push([
          'seed' + n,
          `u${n}@example.com`,
          (n % 3) + 1,
          (n % 4) + 1,
          new Date(Date.now() - (n % 30) * 86400000),
        ]);
      }
      await pool.query(
        'INSERT INTO orders (id,email,product_id,qty,created_at) VALUES ?', [rows]
      );
    }
    console.timeEnd('seed');
    await pool.end();
  })();
  JS
$ cd ~/evtlab && node events/seed-orders.js

1〜2分かかります。20万件入りました。

「読むたびに集計する」版を測る

bash
$ docker exec -i evtlab-mysql mysql -uroot -pevtlab evtlab <<'SQL'
  SET profiling = 1;
  SELECT DATE(o.created_at) AS day, COUNT(*) AS cnt, SUM(p.price * o.qty) AS amount
  FROM orders o JOIN products p ON p.id = o.product_id
  GROUP BY DATE(o.created_at)
  ORDER BY day DESC LIMIT 5;
  SHOW PROFILES;
  SQL

私の環境(VM 2コア)ではこうなりました。

+----------+------------+---------------------------------------+
| Query_ID | Duration   | Query                                 |
+----------+------------+---------------------------------------+
|        1 | 0.41823450 | SELECT DATE(o.created_at) AS day, ... |
+----------+------------+---------------------------------------+

約0.42秒。 画面を開くたびに0.42秒待たされます。しかも注文が増えるほど遅くなり続けます。

EXPLAIN で理由を見ておきます(本線のパフォーマンス改善の回でやった読み方です)。

bash
$ docker exec -i evtlab-mysql mysql -uroot -pevtlab evtlab \
    -e "EXPLAIN SELECT DATE(o.created_at) day, COUNT(*), SUM(p.price*o.qty) FROM orders o JOIN products p ON p.id=o.product_id GROUP BY DATE(o.created_at)\G"

rows が20万に近い数字になり、Using temporary が出ます。全部読んで、その場で集めています。 DATE() で包んでいるので索引も効きません。

「書いたときに集計しておく」版(CQRS)

イベント形なら、すでに sub-stats.js が daily_sales を更新しています。 これが読み専用の形です。

過去分を作り直します(イベントから再構築するつもりのスクリプトです)。

bash
$ cat > ~/evtlab/events/rebuild-readmodel.js <<'JS'
  const { pool } = require('../lib/db');
  (async () => {
    console.time('rebuild');
    await pool.query('DELETE FROM daily_sales');
    await pool.query(`
      INSERT INTO daily_sales (day, order_count, amount)
      SELECT DATE(o.created_at), COUNT(*), SUM(p.price * o.qty)
      FROM orders o JOIN products p ON p.id = o.product_id
      GROUP BY DATE(o.created_at)
    `);
    console.timeEnd('rebuild');
    await pool.end();
  })();
  JS
$ cd ~/evtlab && node events/rebuild-readmodel.js

読むほうを測ります。

bash
$ docker exec -i evtlab-mysql mysql -uroot -pevtlab evtlab <<'SQL'
  SET profiling = 1;
  SELECT day, order_count, amount FROM daily_sales ORDER BY day DESC LIMIT 5;
  SHOW PROFILES;
  SQL
+----------+------------+-------------------------------------------+
| Query_ID | Duration   | Query                                     |
+----------+------------+-------------------------------------------+
|        1 | 0.00046200 | SELECT day, order_count, amount FROM ...  |
+----------+------------+-------------------------------------------+
読み方実行時間行数
毎回 JOIN して GROUP BY約 0.418 秒20万行を読む
daily_sales を1行読む約 0.00046 秒30行

900倍ほど違いました。 そして注文が100万件になっても daily_sales の行数は増えません。

📷 スクリーンショット: SHOW PROFILES; の出力2つを並べて、Duration の桁が違うところ。

CQRS が買っているもの、失っているもの

買っているものは、上のとおり「読みが定数時間になる」ことです。

失っているものは3つあります。

  1. 読み側が遅れます。 sub-stats.js が止まっている間、daily_sales は古いままです。画面は「1分前の売上」を出します
  2. 同じデータが2箇所にあります。 orders と daily_sales がずれる可能性が生まれました。ずれたときに直す手段(再構築スクリプト)が必須になります。上で書いた rebuild-readmodel.js が、実はその保険です
  3. 仕様変更のたびに再構築が要ります。 「商品カテゴリ別も出したい」と言われたら、表を足して、20万件を読み直して埋めることになります

CQRS は「読みの都合で表をもう1つ持つ」ことです。 持った表の数だけ、ずれる可能性と再構築の手間が増えます。

なお、CQRS はイベント駆動と必ずセットではありません。 バッチで1時間に1回集計表を作るのも立派な CQRS です。イベントでやると遅れが数百ミリ秒になる、というだけの違いです。


⑦ イベントソーシング — 状態ではなく、起きたことを保存する

発想を裏返す

ここまでの products.stock は、現在の値を持っていました。

products: id=1, stock=97

「なぜ97なのか」は、どこにも残っていません。 100から3減ったのか、95から2増えたのか、分かりません。

イベントソーシングは、これを裏返します。現在の値を保存せず、起きたことを全部保存します。

deposit  +100
withdraw  -30
withdraw  -20
deposit   +50
────────────
残高 = 100

残高という列はありません。毎回、足して出します。 これを「再生(リプレイ)」と言います。

作る

口座の入出金で作ります。

bash
$ docker exec -i evtlab-mysql mysql -uroot -pevtlab evtlab <<'SQL'
  DROP TABLE IF EXISTS ledger_events;
  DROP TABLE IF EXISTS ledger_snapshots;
  CREATE TABLE ledger_events (
    seq     BIGINT AUTO_INCREMENT PRIMARY KEY,
    account VARCHAR(20) NOT NULL,
    type    VARCHAR(20) NOT NULL,
    amount  INT NOT NULL,
    at      DATETIME NOT NULL,
    INDEX idx_acc (account, seq)
  );
  CREATE TABLE ledger_snapshots (
    account  VARCHAR(20) PRIMARY KEY,
    last_seq BIGINT NOT NULL,
    balance  BIGINT NOT NULL
  );
  SQL

$ cat > ~/evtlab/ledger/append.js <<'JS'
  const { pool } = require('../lib/db');
  (async () => {
    const [,, account, type, amount] = process.argv;
    await pool.query(
      'INSERT INTO ledger_events (account, type, amount, at) VALUES (?,?,?,NOW())',
      [account, type, Number(amount)]
    );
    console.log(`記録: ${account} ${type} ${amount}`);
    await pool.end();
  })();
  JS

$ cat > ~/evtlab/ledger/replay.js <<'JS'
  const { pool } = require('../lib/db');
  (async () => {
    const account = process.argv[2] || 'acc1';
    console.time('replay');
    const [rows] = await pool.query(
      'SELECT type, amount FROM ledger_events WHERE account = ? ORDER BY seq', [account]
    );
    let balance = 0;
    for (const r of rows) {
      if (r.type === 'deposit')  balance += r.amount;
      if (r.type === 'withdraw') balance -= r.amount;
    }
    console.timeEnd('replay');
    console.log(`${account}: イベント ${rows.length} 件を再生 → 残高 ${balance}`);
    await pool.end();
  })();
  JS

動かします。

bash
$ cd ~/evtlab
$ node ledger/append.js acc1 deposit 100
$ node ledger/append.js acc1 withdraw 30
$ node ledger/append.js acc1 withdraw 20
$ node ledger/append.js acc1 deposit 50
$ node ledger/replay.js acc1
replay: 3.821ms
acc1: イベント 4 件を再生 → 残高 100

残高100が、どこにも保存されていないのに出ました。

そして、ここが本当の効き目です。「先週の火曜の残高は?」に答えられます。

bash
$ docker exec -i evtlab-mysql mysql -uroot -pevtlab evtlab \
    -e "SELECT seq, type, amount, at FROM ledger_events WHERE account='acc1' ORDER BY seq;"

3件目までを足せば、その時点の残高が出ます。 普通の balance 列では、過去の値は消えていて二度と出せません。

イベントソーシングが買っているのは「速さ」でも「疎結合」でもありません。 「過去のすべての時点の状態を、後から何度でも出せる」ことです。

会計、在庫、医療記録のように「なぜその値なのか」を説明する義務がある領域で強い理由がこれです。

代償1: 再生が遅くなる

イベントを増やします。

bash
$ cat > ~/evtlab/ledger/seed.js <<'JS'
  const { pool } = require('../lib/db');
  (async () => {
    const N = 300000, BATCH = 2000;
    console.time('seed');
    for (let i = 0; i < N; i += BATCH) {
      const rows = [];
      for (let j = 0; j < BATCH; j++) {
        rows.push(['acc1', (i + j) % 2 ? 'deposit' : 'withdraw', 10, new Date()]);
      }
      await pool.query('INSERT INTO ledger_events (account,type,amount,at) VALUES ?', [rows]);
    }
    console.timeEnd('seed');
    await pool.end();
  })();
  JS
$ cd ~/evtlab && node ledger/seed.js && node ledger/replay.js acc1
replay: 1284.517ms
acc1: イベント 300004 件を再生 → 残高 100

残高を1つ出すのに1.3秒。 しかもこの数字は永久に増え続けます。

対策はスナップショットです。「seq 300000 の時点で残高100だった」と記録しておき、そこから先だけ再生します。

bash
$ cat > ~/evtlab/ledger/snapshot.js <<'JS'
  const { pool } = require('../lib/db');
  (async () => {
    const account = process.argv[2] || 'acc1';
    const [[snap]] = await pool.query(
      'SELECT last_seq, balance FROM ledger_snapshots WHERE account = ?', [account]
    );
    const fromSeq = snap ? snap.last_seq : 0;
    let balance = snap ? Number(snap.balance) : 0;
    const [rows] = await pool.query(
      'SELECT seq, type, amount FROM ledger_events WHERE account=? AND seq>? ORDER BY seq',
      [account, fromSeq]
    );
    let last = fromSeq;
    for (const r of rows) {
      balance += (r.type === 'deposit' ? r.amount : -r.amount);
      last = r.seq;
    }
    await pool.query(
      `INSERT INTO ledger_snapshots (account,last_seq,balance) VALUES (?,?,?)
       ON DUPLICATE KEY UPDATE last_seq=VALUES(last_seq), balance=VALUES(balance)`,
      [account, last, balance]
    );
    console.log(`スナップショット更新: seq=${last} balance=${balance}`);
    await pool.end();
  })();
  JS

$ cat > ~/evtlab/ledger/replay-fast.js <<'JS'
  const { pool } = require('../lib/db');
  (async () => {
    const account = process.argv[2] || 'acc1';
    console.time('replay-fast');
    const [[snap]] = await pool.query(
      'SELECT last_seq, balance FROM ledger_snapshots WHERE account = ?', [account]
    );
    const fromSeq = snap ? snap.last_seq : 0;
    let balance = snap ? Number(snap.balance) : 0;
    const [rows] = await pool.query(
      'SELECT type, amount FROM ledger_events WHERE account=? AND seq>? ORDER BY seq',
      [account, fromSeq]
    );
    for (const r of rows) balance += (r.type === 'deposit' ? r.amount : -r.amount);
    console.timeEnd('replay-fast');
    console.log(`残高 ${balance}(スナップショット以降 ${rows.length} 件のみ再生)`);
    await pool.end();
  })();
  JS

$ cd ~/evtlab && node ledger/snapshot.js acc1 && node ledger/replay-fast.js acc1
スナップショット更新: seq=300004 balance=100
replay-fast: 2.103ms
残高 100(スナップショット以降 0 件のみ再生)

1284ms が 2ms になりました。 ただし、スナップショットを作る仕組みそのものを作って、動かし続けて、失敗したら気づく必要があります。 保存する表が1つ増え、定期実行が1つ増えました(cron や systemd timer の回でやった「黙って止まる」対象が、また1つ増えたということです)。

代償2: 過去のイベントの形を変えられない

これが一番痛いところです。

ledger_events に amount INT があります。あとから「通貨を持ちたい」と思ったとします。普通の表なら列を足して終わりです。

イベントソーシングでは終わりません。 すでに保存されている30万件には currency がありません。再生するコードは、currency が無い古いイベントも読めなければなりません。

// 再生コードは、こうなっていく
const currency = r.currency ?? 'JPY';   // v1 のイベントには無い

3年運用すると、再生コードが「イベントのバージョンごとの分岐」だらけになります。 そして古いイベントは書き換えられません。 書き換えたら「起きたことの記録」ではなくなるからです。

イベントは「一度書いたら永久に読み続ける契約」です。 普通のテーブルなら ALTER TABLE で済んだ変更が、コード側の永久の負債になります。

代償3: 消せない

「この利用者のデータを全部削除してください」と言われたとします。

普通の表なら DELETE で終わりです。イベントソーシングでは、消したら残高が合わなくなります。 イベントは足し算の材料だからです。

現実の対処は、どれも面倒です。

  • 個人情報だけを別の表に置いて、イベントには参照だけ書く(設計時から決めておく必要がある)
  • イベントの中身を暗号化して保存し、鍵を捨てることで実質的に読めなくする
  • イベントを書き換える(監査記録としての価値を失う)

「あとで考える」ができない種類の問題です。

だから、結論はこうです

イベントソーシングは、大半のアプリには要りません。

私の現在の線引きです。

使う使わない
お金の出入り(会計・決済・ポイント)ふつうのCRUDアプリ
「なぜこの値か」の説明義務がある領域ブログ、社内ツール、管理画面
監査ログが法的に必要なもの個人開発の作品
一部の表だけに適用するアプリ全体に適用する

「アプリ全体をイベントソーシングにする」は、ほぼ確実に間違いです。 私は最初これをやろうとして、users テーブルの UserEmailChanged を再生する羽目になり、メールアドレスを1件引くのに20イベント読むという馬鹿げたコードを書きました。普通の表で持てばよかったのです。


⑧ いつイベント駆動にするか

ここまでで測ったものを、判断表にします。

状況どうするか理由
1つのアプリを1人で作っている直接呼ぶ流れが読める価値が、疎結合より大きい
注文APIに「ついでの処理」が2つ以下直接呼ぶ(失敗はログに残す)まだ耐えられる
ついでの処理が3つ以上で、まだ増えそうイベント形にする注文APIを毎回触るコストが上回る
ついでの処理が落ちても注文は通したいイベント形にする①で見た500がまさにこれ
ついでの処理が遅い(外部API・変換・PDF)キューでよい(前回の記事)受け手が1つならイベントにする必要はない
順番と巻き戻しが要る(決済・返金)オーケストレーション補償を1箇所に書きたい
通知・集計など増え続ける付随処理コレオグラフィ足すだけで済む
集計画面が注文の増加で遅くなってきたCQRS(読み用の表)⑥で900倍
過去の時点の状態を出す義務があるその表だけイベントソーシング⑦の唯一の強み
「マイクロサービスっぽいから」やらない代償を4つ払うだけになる

私が守ることにした順番

  1. まず直接呼ぶ。 動くものを先に作る
  2. 痛くなったら測る。 「注文APIを今月何回触ったか」「500の原因は何割が付随処理か」
  3. 痛い1箇所だけイベントにする。 全部を一度に変えない
  4. イベントにするなら、同時に相関ID・ログ集約・冪等を入れる。 3点セットで1つ

足すのは、増える機能に注文APIが耐えられなくなってからです。 耐えているうちにやると、読めなくなっただけの遅いアプリができます。

これは本線のまだマイクロサービスにしない — モノリスと12 Factorと同じ結論です。構造を先に立派にしても、痛みが無ければ利子だけ払うことになります。


つまずいたところ

1. xGroupCreate を '$' で作って、新しい購読に何も届かなかった

sub-slack.js を起動しても、ログが1行も出ませんでした。落ちてもいないのに無反応です。原因は xGroupCreate(STREAM, group, '$') と書いていたことでした。'$' は「このあと来るものだけ」という意味で、すでに流れた分は届きません。 新しい購読を足したときに過去分を処理させたいなら '0' です。逆に「過去は要らない」なら '$' が正しい。どちらが欲しいかを毎回決める必要があります。

2. PUBLISH / SUBSCRIBE を使って、落としている間のイベントが全部消えた

最初は Redis の pub/sub(PUBLISH と SUBSCRIBE)で書いていました。動きます。が、購読側を落として注文し、立て直しても何も届きません。 pub/sub はその瞬間に繋がっている相手にしか配らないからです。届かなかったものは消えます。「イベント形にしたのに、メール担当を再起動したら注文が消えた」という一番まずい事故です。保存が要るなら Streams(またはキュー)を使う。 pub/sub は「今この瞬間の通知」専用だと思ったほうがいい。

3. 3つの購読を同じグループ名で起動して、1つにしか届かなかった

subscribe('worker', ...) を3つのファイルで使い回していました。結果、注文1件につきどれか1つのプロセスだけが動きます。メールが送られたり送られなかったりする、という現象になりました。同じグループ = 仕事の分担、違うグループ = 全員に配布です。前回の記事の「競合するコンシューマ」と「ファンアウト」の違いが、そのままグループ名の違いとして出ます。グループ名は、サービスの名前にする。

4. ack する前に例外が飛んで、同じイベントを永久に処理し続けた

処理の中でエラーが出ると xAck に到達せず、保留に残ります。再起動するとまた同じイベントを読み、また落ちます。 前回の記事でやったのと同じ「毒メッセージ」です。ここでも回数を数えて、一定回数超えたら別のストリームへ逃がす必要があります。XPENDING の出力に配送回数が入っているので、それで判定できます。イベント駆動にしても、この問題は消えません。むしろ受け手の数だけ増えます。

5. 冪等の判定を SELECT してから INSERT にして、二重に処理された

最初こう書いていました。

const [[hit]] = await pool.query('SELECT 1 FROM processed_events WHERE event_id=?', [id]);
if (hit) return;
await pool.query('INSERT INTO processed_events ...');

同じイベントが2つのプロセスにほぼ同時に届くと、両方が「まだ無い」と判定します。 判定と記録の間に隙間があるからです。INSERT IGNORE の affectedRows で判定すれば、DBの主キー制約が1つに絞ってくれます。 「チェックしてから書く」は、並行するとほぼ必ず壊れる形です。

6. daily_sales を CQRS 用にしたのに、sub-stats.js を止めたまま画面を作って「バグだ」と騒いだ

売上が更新されないので集計クエリを疑い、30分溶かしました。止まっていたのは購読プロセスでした。 イベント形にすると、「動いていないと壊れる常駐プロセス」が増えます。 ①の形では、注文APIが動いていればすべて動いていました。いまは4つ全部が動いていないと、静かに一部だけ止まります。 しかもエラーは出ません。購読プロセスの死活監視は必須です。

7. イベントに「注文の全部」を入れるか「IDだけ」を入れるかで迷った

最初は { id: 'a71d' } だけを流し、受け手がDBを引く形にしました。軽いのですが、受け手が全員 orders テーブルを読むことになります。 DBが共有され、疎結合になっていません。逆に全部入れると、イベントが古い情報を運びます(流したあとに注文が変更されたら?)。今回は「注文された時点の事実」なので全部入れるのが正解でした。「イベントは、その時点の事実のコピーを運ぶ」 と考えると迷わなくなりました。

8. MySQL のコンテナが立つ前にアプリを起動して ECONNREFUSED を出した

docker compose up -d の直後に node events/api.js を打つと、MySQL がまだ初期化中で繋がりません。Docker Compose の depends_on はコンテナの起動順しか見ません。 この記事で mysqladmin ping のループを入れているのはそのためです。「起動した」と「受け付けられる」は別です。


後片づけ

立てたものを全部消します。 起動中の端末(api / sub-mail / sub-stock / sub-stats / sub-slack)を、それぞれ Ctrl+C で止めてから実行します。

bash
$ cd ~/evtlab
$ docker compose down -v
$ docker ps -a | grep evtlab || echo "コンテナは残っていません"
$ docker volume ls | grep evtlab || echo "ボリュームも残っていません"

-v を付けているのは、MySQL のデータも一緒に消すためです。付け忘れると20万件のデータが残ります。

作業ディレクトリごと消す場合はこうします。

bash
$ cd ~ && rm -rf ~/evtlab && ls -d ~/evtlab 2>/dev/null || echo "削除しました"

もし途中で止まらなくなったら、こう戻します。

bash
$ docker rm -f evtlab-redis evtlab-mysql 2>/dev/null
$ pkill -f "evtlab" 2>/dev/null || true

📷 スクリーンショット: docker ps -a と docker volume ls に evtlab が1つも残っていないところ。


まとめ — 理解できたこと

  • 直接呼ぶ形の問題は「失敗が伝わること」ではなく、「一部だけ実行された状態」が作れてしまうこと。 メールが落ちただけで、注文はあるのに在庫が減っていない状態を実際に作った
  • try/catch で握りつぶしても直らない。 失敗が消えるだけで、注文APIが3つの都合を知っている構造は残る
  • イベント形にすると、注文APIは「起きたこと」を1本流すだけになる。 レスポンスは 214ms から 6ms になり、購読を1つ落としても注文は 200 を返し続けた
  • 機能を1つ足すとき、既存ファイルを1行も変更しなかった。 これがイベント駆動で買えるものの正体
  • 代わりに、全体の流れがどのファイルにも書かれなくなった。 grep しないと分からず、しかも grep は実行順を教えてくれない
  • 相関ID・ログ集約・冪等は「あると便利」から「無いと運用できない」に変わる。 イベント駆動と同時に入れる3点セット
  • 結果整合は避けられない。 200 が返った時点でメール履歴は0件だった。画面の文言のほうを変えるのが一番安い
  • 「ちょうど1回」は無い。「少なくとも1回」しかない。 ack 前に落として、集計金額が二重に足されるところを実際に見た。INSERT IGNORE の affectedRows で冪等にした
  • コマンドは「やれ」で拒否でき、イベントは「起きた」で拒否できない。 名前を過去形にするのは、責任の置き場所を受け手側に移すため。命令形の名前を使うと、送る側がまた全員の都合を知ることになる
  • オーケストレーションは読みやすく巻き戻しやすい。コレオグラフィは足しやすく、全体が誰にも見えなくなる。 お金が動く流れは前者、増え続ける付随処理は後者、と分けることにした
  • サービスを跨ぐと ROLLBACK は使えない。 打ち消しの処理(補償)を自分で書く義務が生まれる。これも分けたことの代償
  • CQRS は「読む形をあらかじめ作っておく」こと。 20万件の JOIN 集計 0.42秒 に対し、集計表を1行読むと 0.00046秒。900倍近い差が出て、しかも件数が増えても変わらない
  • その代わり、同じデータが2箇所になり、ずれる。 再構築スクリプトは保険ではなく必須部品だった
  • イベントソーシングが買えるのは速さでも疎結合でもなく、「過去のすべての時点の状態を出せる」こと。 30万件で再生1.28秒、スナップショットで2msまで戻せたが、そのスナップショット機構を作って運用する仕事が増えた
  • イベントソーシングの本当の代償は、形を変えられないことと、消せないこと。 イベントは一度書いたら永久に読み続ける契約になる。大半のアプリには要らない
  • 1つのアプリを1人で作っているなら、直接呼ぶ形で十分。 足すのは、増える機能に注文APIが耐えられなくなってから。耐えているうちにやると、読めなくなっただけの遅いアプリができる

参考リンク


次に読む

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

記事
← 前の記事データストアの選び方 — 速いのはJOINをしていないから
→ 次の記事遅いアプリのアンチパターン7つ — 推測では当たらない

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

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

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

System Design›System Design — Event Driven
  • コマンドとイベントの違い
  • CQRS とイベントソーシングの代償

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

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

コメント

コメントする

目次