遅いアプリのアンチパターン7つ — 推測では当たらない

遅いアプリのアンチパターン。性能を調べるノートパソコンと虫眼鏡、ストップウォッチと工具。

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

作っていた練習用のアプリで、一覧ページが 0.5秒 かかるようになりました。1万件しか入っていないのにです。

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

これは【深掘り】の記事です。本線の順路ではありません。 読まなくても先へ進めます。 本線の速くする前に必ず測る — パフォーマンス改善とEXPLAINの回の続きにあたります。あの回では「まず測る」という順番と、EXPLAIN の読み方をやりました。 この記事はその先です。「遅くなる書き方」のほうを、7つ、自分の手でわざと書いて測ります。

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

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


私は画面を見て、こう考えました。

「SELECT * を書いているのがいけないんだろう。列を指定すれば速くなるはずだ」

30分かけて、全部の SELECT * を列指定に書き換えました。もう一度測りました。

前後
一覧ページ512ms501ms

2%です。 30分かけて、2%でした。

そのあと、ようやく順番どおりに測りました。アプリのログにSQLを1本ずつ出しただけです。 そうしたら、こう出ました。

[sql] SELECT id, title, author_id FROM posts ... 4.9ms
[sql] SELECT name FROM authors WHERE id = 12  4.6ms
[sql] SELECT name FROM authors WHERE id = 87  4.7ms
[sql] SELECT name FROM authors WHERE id = 3   4.6ms
... (この行があと97本)

101本走っていました。 1本は5ミリ秒未満で、どれも「遅いSQL」ではありません。遅かったのは回数のほうでした。

1回が速いことと、全体が速いことは、関係がありません。

このとき私が踏んでいたのは、名前の付いている失敗でした。Chatty I/O(おしゃべりなI/O)といいます。他にも、名前が付いていて、初学者がほぼ確実に踏むものが並んでいます。

この記事では、それを7つ、全部わざと自分で書いて、測って、直して、また測ります。 図で「N+1問題は良くない」と読んでも身に付きません。101本走っているところを自分の目で見ないと、次に書くときにまた書きます。

そして最後の⑦が、この記事で一番大事な節です。冒頭の「30分かけて2%」を、実際に手元で再現します。

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

目次

この記事でわかること

  • 「遅いアプリ」の書き方には名前が付いていること。N+1、余分な取得、同期I/O、毎回の生成、DBに仕事をさせすぎ、うるさい隣人。知っていれば書く前に避けられること
  • 1回の処理が速いことは、全体が速いことをまったく保証しないこと。回数 × 往復時間 が効くので、1本1ミリ秒でも101本なら0.1秒になること
  • 絞り込みは、データベースの中でやるほうが必ず速いこと。アプリ側に持ってきてから絞るのは、要らないデータの分だけネットワークとメモリを使ってから捨てているだけだということ
  • Node.js の同期I/Oは、そのリクエストだけを遅くするのではないこと。同時に来ている他の全リクエストが止まること。しかもログには「その1本が遅い」としか出ないこと
  • データベースは、システムの中で一番増やしにくい部品だということ。だからアプリでできる仕事をDBに投げてはいけないこと。同時に、索引で済む仕事をアプリでやるのも同じくらい悪いこと
  • そして一番大事なこと: 推測で直した箇所は、たいてい全体の数%しか占めていないこと。直す順番は「効く順」で、それは測らないと分からないこと

この記事でやること

  1. ~/aplab に MySQL を1つ立て、1万件のダミーデータを入れて、時間を測る土台を作る
  2. ① N+1問題: SQLを101回打つ版と、JOIN 1回の版を両方書いて測り、何倍かを出す
  3. ② 余分に取りすぎる/③ 同期I/O/④ 毎回作り直すを、それぞれ「悪い版 → 実測 → 直した版 → 実測」の形で書く
  4. ⑤ DBに仕事をさせすぎると、その逆の索引で済む仕事をアプリでやるを、対で作って測る
  5. ⑥ 1本の重い処理が、同居する軽いAPIを巻き込むところを再現し、分けて直す
  6. ⑦ 推測で直して2%しか変わらないところを実際に作り、測ってから直すと何倍になるかを見る
  7. 症状 → 疑う場所 → 確かめ方の表にまとめて、立てたものを全部消す

先に知る言葉

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

言葉意味
アンチパターン「よくやってしまう、悪いやり方」に名前を付けたもの。 設計パターンの反対。名前が付いていると、書く前に気づける
N+1問題一覧を1回取ったあと、その1件ごとに追加のSQLを打ってしまうこと。 100件なら 1 + 100 = 101回。Chatty I/O の代表例
往復時間(ラウンドトリップ)命令を送ってから答えが返るまでの時間。 同じVMの中でも 0.3〜1ミリ秒はかかる。回数を掛けた値が効く
コネクションプールデータベースへの接続を、あらかじめ何本か作って使い回す仕組み。 使い終わったら閉じずに「返す」。接続を張る時間を毎回払わずに済む
イベントループNode.js が「次にやる仕事」を回している1本の輪。 ここが1つの処理で塞がると、他の全リクエストが待つ
同期I/O読み終わるまでその行で止まる入出力。readFileSync など。Node.js ではイベントループごと止まる
バルクヘッド船の隔壁のこと。 資源(接続・スレッド・プール)を用途ごとに分けて、1か所の障害を他へ漏らさない設計
プロファイル「どこに何ミリ秒かかったか」の内訳。 合計だけ見ても直す場所は分からない。内訳が無いと推測になる
ダミーデータ測るために用意する、それらしい形の仮データ。 10件では差が出ない。1万件入れて初めて見える差がある

準備 — 測る土台を作る

ここは全部「端末1」で打ちます。 すべてVMの中です。

1. 作業ディレクトリを作る

bash
$ mkdir -p ~/aplab && cd ~/aplab
$ pwd
/home/ubuntu/aplab

pwd がこの形で返らなければ、以降のコマンドは打たないでください。

2. MySQL を1つ立てる

bash
$ cat > docker-compose.yml <<'EOF'
  services:
    db:
      image: mysql:8.0
      container_name: aplab-db
      environment:
        MYSQL_ROOT_PASSWORD: aplabpass
        MYSQL_DATABASE: aplab
      ports:
        - "127.0.0.1:3307:3306"
      command: --max_connections=200
      healthcheck:
        test: ["CMD", "mysqladmin", "ping", "-h", "127.0.0.1", "-paplabpass"]
        interval: 3s
        timeout: 3s
        retries: 20
  EOF

ポートは 3307 にしています。 すでにVMで MySQL を動かしていても、ぶつからないようにするためです。127.0.0.1: を頭に付けているので、VMの外からは繋がりません。 練習用のパスワードなので、これで十分です。

立てます。

bash
$ docker compose up -d
[+] Running 2/2
 ✔ Network aplab_default  Created
 ✔ Container aplab-db     Started

起動を待ちます。 MySQL は「コンテナが起動した」あと、10〜30秒ほど初期化にかかります。

bash
$ docker compose ps
NAME        IMAGE       STATUS                   PORTS
aplab-db    mysql:8.0   Up 25 seconds (healthy)  127.0.0.1:3307->3306/tcp

(healthy) が出るまで待ってください。 (health: starting) の間に次へ進むと、接続エラーになります。

3. Node.js の準備

bash
$ cd ~/aplab
$ npm init -y >/dev/null
$ npm pkg set type=module
$ npm install mysql2
added 11 packages in 2s

type=module にしているのは、この記事のコードを全部 import で書くためです。

4. 共通の道具を1つ作る

毎回「時間を測って表示する」コードを書くのは無駄なので、先に道具にします。

bash
$ mkdir -p ~/aplab/lib
$ cat > ~/aplab/lib/measure.mjs <<'EOF'
  export const DB = {
    host: '127.0.0.1',
    port: 3307,
    user: 'root',
    password: 'aplabpass',
    database: 'aplab',
  };
  
  // fn を n 回まわして、1回あたりの平均ミリ秒を返す
  export async function measure(label, n, fn) {
    await fn();                        // 1回目は捨てる(暖機)
    const t0 = process.hrtime.bigint();
    for (let i = 0; i < n; i++) await fn();
    const t1 = process.hrtime.bigint();
    const total = Number(t1 - t0) / 1e6;
    console.log(
      `${label.padEnd(28)} 合計 ${total.toFixed(1)}ms  /  1回 ${(total / n).toFixed(2)}ms`
    );
    return total / n;
  }
  EOF

await fn() を1回捨てているのは意図的です。 1回目には接続の確立やクエリキャッシュの都合が混ざります。1回目を混ぜたまま「速くなった」と言うのが、測定でいちばんよくある嘘です。

5. テーブルとダミーデータ

1万件入れます。 10件では、この記事の差はどれも見えません。

bash
$ cat > ~/aplab/seed.mjs <<'EOF'
  import mysql from 'mysql2/promise';
  import { DB } from './lib/measure.mjs';
  
  const c = await mysql.createConnection(DB);
  
  await c.query('DROP TABLE IF EXISTS posts');
  await c.query('DROP TABLE IF EXISTS authors');
  
  await c.query(`
    CREATE TABLE authors (
      id   INT PRIMARY KEY,
      name VARCHAR(60) NOT NULL,
      bio  VARCHAR(200) NOT NULL
    )`);
  
  await c.query(`
    CREATE TABLE posts (
      id         INT PRIMARY KEY,
      author_id  INT NOT NULL,
      title      VARCHAR(120) NOT NULL,
      body       TEXT NOT NULL,
      views      INT NOT NULL,
      created_at DATETIME NOT NULL
    )`);
  
  const authors = [];
  for (let i = 1; i <= 200; i++) {
    authors.push([i, `著者${String(i).padStart(3, '0')}`, 'x'.repeat(180)]);
  }
  await c.query('INSERT INTO authors (id, name, bio) VALUES ?', [authors]);
  
  const body = 'あ'.repeat(400);   // 1件あたり本文を少し重くする
  const rows = [];
  for (let i = 1; i <= 10000; i++) {
    rows.push([
      i,
      (i % 200) + 1,
      `記事タイトル ${i}`,
      body,
      Math.floor(Math.random() * 10000),
      new Date(Date.now() - i * 3600_000),
    ]);
  }
  for (let i = 0; i < rows.length; i += 1000) {
    await c.query(
      'INSERT INTO posts (id, author_id, title, body, views, created_at) VALUES ?',
      [rows.slice(i, i + 1000)]
    );
  }
  
  const [[{ n }]] = await c.query('SELECT COUNT(*) AS n FROM posts');
  console.log(`posts: ${n} 件 / authors: 200 件`);
  await c.end();
  EOF

$ node ~/aplab/seed.mjs
posts: 10000 件 / authors: 200 件

わざと索引を1つも張っていません。 ここに索引を足すと⑤と⑦の実験が成立しないためです。必要になった節で、そのつど張ります。

スクリーンショットを撮ってください: 01_土台ができた.png docker compose ps が (healthy) を返している画面と、node seed.mjs が posts: 10000 件 を返した画面を、続けて撮ってください。この2つが揃っていないと、以降の数字は再現しません。


① おしゃべりなI/O — SQLを101回打つ

冒頭で踏んだやつです。 100件の投稿一覧に、それぞれの著者名を付けて返したい。

悪い版を書く

bash
$ cat > ~/aplab/a1-chatty.mjs <<'EOF'
  import mysql from 'mysql2/promise';
  import { DB, measure } from './lib/measure.mjs';
  
  const c = await mysql.createConnection(DB);
  
  // 悪い版: 一覧を1回 + 1件ごとに著者名を1回 = 101回
  async function chatty() {
    const [posts] = await c.query(
      'SELECT id, title, author_id FROM posts ORDER BY id LIMIT 100'
    );
    for (const p of posts) {
      const [[a]] = await c.query(
        'SELECT name FROM authors WHERE id = ?', [p.author_id]
      );
      p.author = a.name;
    }
    return posts;
  }
  
  // 直した版: JOIN で1回
  async function joined() {
    const [rows] = await c.query(`
      SELECT p.id, p.title, a.name AS author
      FROM posts p JOIN authors a ON a.id = p.author_id
      ORDER BY p.id LIMIT 100`);
    return rows;
  }
  
  // 両方が同じ結果を返すことを先に確かめる
  const x = await chatty(), y = await joined();
  console.log('同じ結果か:', x.length === y.length && x[0].author === y[0].author);
  console.log('SQLの回数:  chatty=101  joined=1');
  console.log('---');
  
  const a = await measure('① 悪い版 (101回)', 20, chatty);
  const b = await measure('① 直した版 (JOIN 1回)', 20, joined);
  console.log(`--- ${(a / b).toFixed(1)} 倍の差 ---`);
  
  await c.end();
  EOF

$ node ~/aplab/a1-chatty.mjs

私のVMではこう出ました。

同じ結果か: true
SQLの回数:  chatty=101  joined=1
---
① 悪い版 (101回)             合計 3054.0ms  /  1回 152.70ms
① 直した版 (JOIN 1回)         合計 116.0ms  /  1回 5.80ms
--- 26.3 倍の差 ---

何が起きているか

SQLの回数1回あたり合計
悪い版101回約 1.5ms152.7ms
直した版1回5.8ms5.8ms

注目してほしいのは、1回あたりの数字です。

悪い版のSQLは、1本 1.5ミリ秒です。JOIN 1本の 5.8ミリ秒より「速い」のです。

だから slow_query_log には1本も引っかかりません。 遅いのはどのSQLか — SQL深掘りの回で見たとおり、遅いSQLを探す道具は「1本ずつ」しか見ません。回数の問題は、遅いSQLを探しても永久に見つかりません。

効くのは 回数 × 往復時間 です。

  • 同じVMの中で 1.5ms × 101 = 152ms
  • これがDBを別サーバーに置いた構成(往復 3ms)なら 300ms を超えます
  • アプリを速くしていないのに、DBを別マシンに分けただけで一覧が2倍遅くなる。 N+1を抱えたままスケールアウトすると、これが起きます

JOIN が使えないときの直し方

外部APIを100回叩くような、JOINできない相手もあります。そのときは「まとめて1回」にします。

bash
$ cat > ~/aplab/a1-batch.mjs <<'EOF'
  import mysql from 'mysql2/promise';
  import { DB, measure } from './lib/measure.mjs';
  const c = await mysql.createConnection(DB);
  
  async function batched() {
    const [posts] = await c.query(
      'SELECT id, title, author_id FROM posts ORDER BY id LIMIT 100');
    const ids = [...new Set(posts.map(p => p.author_id))];
    const [as] = await c.query('SELECT id, name FROM authors WHERE id IN (?)', [ids]);
    const map = new Map(as.map(a => [a.id, a.name]));
    for (const p of posts) p.author = map.get(p.author_id);
    return posts;
  }
  await measure('① まとめ取り (2回)', 20, batched);
  await c.end();
  EOF

$ node ~/aplab/a1-batch.mjs
① まとめ取り (2回)             合計 133.4ms  /  1回 6.67ms

101回が2回になりました。 6.67ms は JOIN 版とほぼ同じです。「1件ずつループの中で問い合わせる」という形そのものが問題であって、JOINが使えるかどうかは本質ではありません。

ループの中に、ネットワークを越える処理を書かない。 これが①の結論です。


② 余分に取りすぎる — 全部持ってきてから捨てる

「著者7番の、直近30日の記事のタイトル一覧」が欲しい。 私が最初に書いたのはこれでした。

悪い版を書く

bash
$ cat > ~/aplab/a2-fetch.mjs <<'EOF'
  import mysql from 'mysql2/promise';
  import { DB, measure } from './lib/measure.mjs';
  const c = await mysql.createConnection(DB);
  
  const since = new Date(Date.now() - 30 * 24 * 3600_000);
  
  // 悪い版: 全列・全行を取ってアプリで絞る
  async function fetchAll() {
    const [rows] = await c.query('SELECT * FROM posts');
    return rows
      .filter(r => r.author_id === 7 && r.created_at >= since)
      .map(r => ({ id: r.id, title: r.title }));
  }
  
  // 直した版: DBの中で絞り、要る列だけ取る
  async function fetchNarrow() {
    const [rows] = await c.query(
      'SELECT id, title FROM posts WHERE author_id = ? AND created_at >= ?',
      [7, since]);
    return rows;
  }
  
  const a = await fetchAll(), b = await fetchNarrow();
  console.log(`取れた件数: 悪い版 ${a.length} / 直した版 ${b.length}`);
  console.log('---');
  const ta = await measure('② 悪い版 (SELECT *)', 10, fetchAll);
  const tb = await measure('② 直した版 (WHERE + 列)', 10, fetchNarrow);
  console.log(`--- ${(ta / tb).toFixed(0)} 倍の差 ---`);
  await c.end();
  EOF

$ node ~/aplab/a2-fetch.mjs
取れた件数: 悪い版 4 / 直した版 4
---
② 悪い版 (SELECT *)          合計 4126.3ms  /  1回 412.63ms
② 直した版 (WHERE + 列)        合計 9.4ms  /  1回 0.94ms
--- 439 倍の差 ---

結果は同じ4件です。 それを出すのに、片方は 412ミリ秒、片方は 0.94ミリ秒かかりました。

何ミリ秒ではなく、何バイト運んだかを見る

時間だけ見ると「なぜか遅い」で終わります。 運んだ量を見ます。

bash
$ docker compose exec -T db mysql -uroot -paplabpass aplab \
    -e "SHOW STATUS LIKE 'Bytes_sent'"

node a2-fetch.mjs の前後で打つと、私の環境では 約 14.2MB 増えていました。直した版だけを10回まわしたときは 約 6KB です。

取った行取った列転送量(10回分)
悪い版10,000行全部(本文含む)約 14.2MB
直した版4行2列約 6KB

約2,400分の1です。 使ったのは4行なので、残りの 9,996行は、運んで、パースして、捨てただけです。

SELECT * そのものが罪なのではありません。 本当の問題は2つです。

  1. 要らない行を運んだ(WHERE をアプリ側でやった)
  2. 要らない列を運んだ(body は TEXT で1件800バイト超。使っていないのに全部運んだ)

「絞り込みは、データの近くでやるほど速い。」 DBの中で絞れば、ネットワークにもアプリのメモリにも、要らないデータは1バイトも乗りません。

これを直しても、まだ遅い

直した版の 0.94ms は「10,000行を全部見た結果」です。 索引がまだ無いからです。

bash
$ docker compose exec -T db mysql -uroot -paplabpass aplab \
    -e "EXPLAIN SELECT id, title FROM posts WHERE author_id = 7"
id  select_type  table  type  possible_keys  key   rows   Extra
 1  SIMPLE       posts  ALL   NULL           NULL  9820   Using where

type: ALL、key: NULL。 全件走査です。索引を張ります。

bash
$ docker compose exec -T db mysql -uroot -paplabpass aplab \
    -e "CREATE INDEX idx_author_created ON posts (author_id, created_at)"
$ node ~/aplab/a2-fetch.mjs
② 直した版 (WHERE + 列)        合計 2.1ms  /  1回 0.21ms

0.94ms → 0.21ms。さらに4.5倍です。 索引がなぜ効くのか、なぜ効かないことがあるのかは 索引を張ったのに使われない — SQL深掘りにまとめてあります。


③ 同期I/Oで詰まる — 1本が全部を止める

ここが Node.js に固有で、しかも一番わかりにくいところです。

悪い版のサーバーを書く

まず、重い読み込み用のファイルを作ります。

bash
$ head -c 64M /dev/urandom > ~/aplab/big.bin
$ ls -lh ~/aplab/big.bin
-rw-rw-r-- 1 ubuntu ubuntu 64M Sep 28 10:12 /home/ubuntu/aplab/big.bin
bash
$ cat > ~/aplab/a3-sync.mjs <<'EOF'
  import http from 'node:http';
  import fs from 'node:fs';
  import fsp from 'node:fs/promises';
  
  const MODE = process.argv[2] === 'async' ? 'async' : 'sync';
  const FILE = new URL('./big.bin', import.meta.url);
  
  http.createServer(async (req, res) => {
    if (req.url === '/ping') {           // 何もしない軽いAPI
      res.end('pong');
      return;
    }
    if (req.url === '/report') {         // 重い読み込み
      let buf;
      if (MODE === 'sync') buf = fs.readFileSync(FILE);       // ← 止まる
      else                 buf = await fsp.readFile(FILE);    // ← 止まらない
      res.end(String(buf.length));
      return;
    }
    res.statusCode = 404; res.end();
  }).listen(3000, () => console.log(`mode=${MODE} listening on 3000`));
  EOF

違いは1行だけです。 readFileSync か await readFile か。

測る

端末1でサーバーを起動します。

bash
$ node ~/aplab/a3-sync.mjs sync
mode=sync listening on 3000

端末2で、/report を叩き続けながら /ping の時間を測ります。測定には ab を使います。

bash
$ sudo apt install -y apache2-utils
bash
$ cd ~/aplab
$ # 裏で /report を叩き続ける
$ ( for i in $(seq 1 60); do curl -s -o /dev/null http://127.0.0.1:3000/report; done ) &
$ # その間に /ping を測る
$ ab -q -n 300 -c 10 http://127.0.0.1:3000/ping | grep -E 'Time per request|50%|99%'
$ wait
Time per request:       742.116 [ms] (mean)
  50%    698
  99%   1584

/ping は res.end('pong') の1行です。 データベースにも触っていません。それが 平均742ミリ秒 かかりました。

直した版

端末1 で Ctrl+C して、async で立て直します。

bash
$ node ~/aplab/a3-sync.mjs async

端末2 で同じことをします。

bash
$ cd ~/aplab
$ ( for i in $(seq 1 60); do curl -s -o /dev/null http://127.0.0.1:3000/report; done ) &
$ ab -q -n 300 -c 10 http://127.0.0.1:3000/ping | grep -E 'Time per request|50%|99%'
$ wait
Time per request:         9.632 [ms] (mean)
  50%      8
  99%     31
モード/ping の平均/ping の99%
readFileSync742ms1584ms
await readFile9.6ms31ms

77倍です。 変えたのは、/ping とは何の関係もない /report の1行だけです。

ここが怖い理由

アプリのログを見ても、「/ping が遅い」としか出ません。

/ping のコードには何も悪いところがありません。そこを何時間見ても、原因は絶対に見つかりません。 犯人は隣のエンドポイントです。

Node.js は 1本のイベントループで全部のリクエストを回しています(非同期処理の基本の回でやった await の土台です)。readFileSync はその輪を、読み終わるまで完全に止めます。 止まっている間、他の全リクエストは受け付けられてすらいません。

同じことが起きるコードは readFileSync だけではありません。

止める書き方代わりに
fs.readFileSync / writeFileSyncfs/promises の await 版
JSON.parse に巨大な文字列を渡す分割して読む、あるいはワーカーへ逃がす
何十万回まわる for ループ分割して await を挟む、ワーカーへ逃がす
crypto の同期ハッシュを重い回数でcrypto の非同期API
child_process.execSyncexec の Promise 版

共通点は「CPUかI/Oを、await せずに長時間握ること」です。


④ 毎回作り直す — 接続は張り直すたびに金を払う

悪い版を書く

bash
$ cat > ~/aplab/a4-pool.mjs <<'EOF'
  import mysql from 'mysql2/promise';
  import { DB, measure } from './lib/measure.mjs';
  
  // 悪い版: リクエストのたびに接続を作って閉じる
  async function perRequest() {
    const c = await mysql.createConnection(DB);
    const [[r]] = await c.query('SELECT id, title FROM posts WHERE id = 42');
    await c.end();
    return r;
  }
  
  // 直した版: プールから借りて返す
  const pool = mysql.createPool({ ...DB, connectionLimit: 10 });
  async function pooled() {
    const [[r]] = await pool.query('SELECT id, title FROM posts WHERE id = 42');
    return r;
  }
  
  const a = await measure('④ 悪い版 (毎回接続)', 100, perRequest);
  const b = await measure('④ 直した版 (プール)', 100, pooled);
  console.log(`--- ${(a / b).toFixed(1)} 倍の差 ---`);
  await pool.end();
  EOF

$ node ~/aplab/a4-pool.mjs
④ 悪い版 (毎回接続)            合計 2310.4ms  /  1回 23.10ms
④ 直した版 (プール)            合計 96.2ms  /  1回 0.96ms
--- 24.1 倍の差 ---

何に23ミリ秒かかっているのか

SQL自体は主キー1件の取得です。0.3ミリ秒もかかりません。 残りは全部、接続を張る作業です。

  1. TCP の三方向ハンドシェイク
  2. MySQL の認証(caching_sha2_password の交換)
  3. セッション変数の初期化
  4. 終わったら、閉じるためのやりとり

これを、SQL 1本のたびに全部やっています。

接続が実際に増減しているところを見ます。端末2で:

bash
$ docker compose exec -T db mysql -uroot -paplabpass \
    -e "SHOW GLOBAL STATUS LIKE 'Connections'"

a4-pool.mjs の前後で打つと、200以上増えています(悪い版100回 + プール作成分)。プールだけを1000回まわしても、増えるのは10本までです。

これは「毎回作るのが遅い」ものすべてに当てはまります。

毎回作りがちなもの本来は
DBの接続プールを1つ作ってアプリ全体で使う
HTTPクライアント1個作って使い回す(Keep-Alive が効く)
正規表現オブジェクト(ループ内の new RegExp)外で1回作る
設定ファイルの読み込み・パース起動時に1回
暗号鍵の導出起動時に1回

名前は Improper Instantiation(不適切な生成)です。 「重い準備を、要求のたびにやり直している」という一形です。

ただし、プールにすれば無条件で速いわけではありません。 connectionLimit を大きくしすぎると、DB側の max_connections を食い潰して全体が落ちます。 練習でも10で十分です。プールの正しい大きさは「DBのコア数の2倍前後」から始めて、測って決めます。


⑤ DBに仕事をさせすぎる — と、その逆

この2つは、鏡写しです。片方だけ知っていると、直したつもりで逆側へ倒れます。

悪い版その1: DBに文字列処理をさせる

「タイトルを大文字化して、記号を除いて、先頭10文字ごとに集計したい」。SQLで書けます。

bash
$ cat > ~/aplab/a5-busydb.mjs <<'EOF'
  import mysql from 'mysql2/promise';
  import { DB, measure } from './lib/measure.mjs';
  const pool = mysql.createPool({ ...DB, connectionLimit: 10 });
  
  // 悪い版: 加工も集計も全部SQLでやる(索引がまったく効かない形)
  async function busyDb() {
    const [rows] = await pool.query(`
      SELECT UPPER(REPLACE(SUBSTRING(title, 1, 10), ' ', '')) AS k,
             COUNT(*) AS n, SUM(views) AS v
      FROM posts
      WHERE LOWER(title) LIKE '%記事%'
      GROUP BY k ORDER BY n DESC LIMIT 20`);
    return rows;
  }
  
  // 直した版: DBは「絞る・数える」だけ。加工はアプリ側
  async function appSide() {
    const [rows] = await pool.query(
      'SELECT title, views FROM posts WHERE created_at >= ?',
      [new Date(Date.now() - 400 * 24 * 3600_000)]);
    const m = new Map();
    for (const r of rows) {
      const k = r.title.slice(0, 10).replace(/ /g, '').toUpperCase();
      const e = m.get(k) ?? { k, n: 0, v: 0 };
      e.n++; e.v += r.views; m.set(k, e);
    }
    return [...m.values()].sort((a, b) => b.n - a.n).slice(0, 20);
  }
  
  const a = await measure('⑤ 悪い版 (DBで加工)', 5, busyDb);
  const b = await measure('⑤ 直した版 (アプリで加工)', 5, appSide);
  console.log(`--- ${(a / b).toFixed(1)} 倍の差 ---`);
  await pool.end();
  EOF

$ node ~/aplab/a5-busydb.mjs
⑤ 悪い版 (DBで加工)           合計 7104.5ms  /  1回 1420.90ms
⑤ 直した版 (アプリで加工)       合計 216.0ms  /  1回 43.20ms
--- 32.9 倍の差 ---

測っている最中に、DBのCPUを見ます。 端末2で:

bash
$ docker stats --no-stream aplab-db
CONTAINER   NAME       CPU %     MEM USAGE / LIMIT
aplab-db    aplab-db   98.42%    412MiB / 3.8GiB

98%です。 悪い版が走っている間、このDBは他の誰の役にも立てません。

なぜこれが特別に悪いのか

データベースは、システムの中で一番増やしにくい部品です。

  • アプリサーバーは docker compose up --scale で3台にできます
  • データベースは、書き込みを受ける側は原則1台です。増やすにはレプリケーションの設計や分割が要り、整合性の話がまるごと付いてきます

アプリ側のCPUは「増やせる資源」で、DBのCPUは「増やせない資源」です。 増やせない側で燃やしていい仕事は、そこでしかできない仕事だけです。

DBがやるべき仕事アプリがやるべき仕事
索引を使った絞り込み(WHERE / JOIN / ORDER BY ... LIMIT)表示用の文字列整形
件数・合計(COUNT / SUM)索引が効く形で日付の書式、通貨記号、丸め
一意性・外部キーなどの整合性の保証分岐の多い業務ルール
トランザクションHTML・JSONの組み立て

悪い版その2(逆側): 索引で済む仕事をアプリでやる

「じゃあ全部アプリでやればいい」は間違いです。 ②で見たのと同じ罠に戻ります。

bash
$ cat > ~/aplab/a5-busyfront.mjs <<'EOF'
  import mysql from 'mysql2/promise';
  import { DB, measure } from './lib/measure.mjs';
  const pool = mysql.createPool({ ...DB, connectionLimit: 10 });
  
  // 悪い版: 全件取ってアプリで並べ替えて上位10件
  async function busyFront() {
    const [rows] = await pool.query('SELECT id, title, views FROM posts');
    return rows.sort((a, b) => b.views - a.views).slice(0, 10);
  }
  
  // 直した版: 索引つきの ORDER BY ... LIMIT
  async function dbSort() {
    const [rows] = await pool.query(
      'SELECT id, title, views FROM posts ORDER BY views DESC LIMIT 10');
    return rows;
  }
  
  const a = await measure('⑤逆 悪い版 (アプリでsort)', 10, busyFront);
  const b = await measure('⑤逆 直した版 (索引+LIMIT)', 10, dbSort);
  console.log(`--- ${(a / b).toFixed(1)} 倍の差 ---`);
  await pool.end();
  EOF

$ docker compose exec -T db mysql -uroot -paplabpass aplab \
    -e "CREATE INDEX idx_views ON posts (views DESC)"
$ node ~/aplab/a5-busyfront.mjs
⑤逆 悪い版 (アプリでsort)      合計 3802.1ms  /  1回 380.21ms
⑤逆 直した版 (索引+LIMIT)      合計 11.4ms  /  1回 1.14ms
--- 333.5 倍の差 ---

333倍です。 10,000行を運んで並べ替えて、9,990行を捨てていました。

境界線は「DBか、アプリか」ではありません。「索引で消せる仕事か、そうでないか」です。 索引で消せる仕事はDBへ。索引で消せない加工はアプリへ。

UPPER() や LIKE '%…%' を WHERE に書くと索引が使えなくなります。あれが悪かったのは「DBでやったから」ではなく、「索引を殺す書き方でDBにやらせたから」です。詳しくは JOINは表を繋いでいない — SQL深掘りと索引の回にあります。

スクリーンショットを撮ってください: 02_DBのCPUが張り付く.png node a5-busydb.mjs を走らせている最中に、別の端末で docker stats --no-stream aplab-db を打ち、CPU が 90% を超えている画面を撮ってください。「増やせない部品を燃やしている」のがこの数字です。


⑥ うるさい隣人 — 1本が全部を巻き込む

③はイベントループの話でした。⑥は共有資源の話です。プールを分けていないと、重い処理が接続を全部握ります。

悪い版を書く

bash
$ cat > ~/aplab/a6-noisy.mjs <<'EOF'
  import http from 'node:http';
  import mysql from 'mysql2/promise';
  import { DB } from './lib/measure.mjs';
  
  const SPLIT = process.argv[2] === 'split';
  
  // 悪い版: 全機能が1つのプール(5本)を共有
  const shared = mysql.createPool({ ...DB, connectionLimit: 5 });
  // 直した版: 重いレポート専用に2本だけ切り出す(バルクヘッド)
  const light  = mysql.createPool({ ...DB, connectionLimit: 5 });
  const heavy  = mysql.createPool({ ...DB, connectionLimit: 2 });
  
  const forLight  = () => (SPLIT ? light : shared);
  const forReport = () => (SPLIT ? heavy : shared);
  
  const HEAVY = `
    SELECT UPPER(REPLACE(SUBSTRING(title,1,10),' ','')) AS k, COUNT(*) n
    FROM posts WHERE LOWER(title) LIKE '%記事%' GROUP BY k`;
  
  http.createServer(async (req, res) => {
    try {
      if (req.url === '/ping') {
        const [[r]] = await forLight().query('SELECT 1 AS ok');
        res.end('ok' + r.ok);
      } else if (req.url === '/report') {
        const [rows] = await forReport().query(HEAVY);
        res.end(String(rows.length));
      } else { res.statusCode = 404; res.end(); }
    } catch (e) { res.statusCode = 500; res.end(e.code ?? 'err'); }
  }).listen(3000, () => console.log(`split=${SPLIT} listening on 3000`));
  EOF

端末1 で悪い版を起動します。

bash
$ node ~/aplab/a6-noisy.mjs
split=false listening on 3000

端末2 で、まず平常時の /ping を測ります。

bash
$ ab -q -n 200 -c 5 http://127.0.0.1:3000/ping | grep 'Time per request' | head -1
Time per request:       1.104 [ms] (mean)

次に、重いレポートを5本同時に走らせながら、同じ測定をします。

bash
$ for i in 1 2 3 4 5; do curl -s -o /dev/null http://127.0.0.1:3000/report & done
$ ab -q -n 200 -c 5 http://127.0.0.1:3000/ping | grep 'Time per request' | head -1
$ wait
Time per request:      2050.884 [ms] (mean)

1.1ms → 2050ms。1860倍です。 /ping は SELECT 1 です。中身は何も変わっていません。空いている接続が1本も無いので、順番待ちをしているだけです。

直す — 資源を分ける(バルクヘッド)

端末1 を Ctrl+C して、split で立て直します。

bash
$ node ~/aplab/a6-noisy.mjs split

端末2 で同じ測定です。

bash
$ for i in 1 2 3 4 5; do curl -s -o /dev/null http://127.0.0.1:3000/report & done
$ ab -q -n 200 -c 5 http://127.0.0.1:3000/ping | grep 'Time per request' | head -1
$ wait
Time per request:         4.812 [ms] (mean)
/ping の平均
平常時1.1ms
悪い版(プール共有・レポート5本)2050ms
直した版(プールを分ける)4.8ms

426倍改善しました。 重いレポート自体はむしろ遅くなっています(使える接続が2本に減ったので)。

バルクヘッドは、全体を速くする道具ではありません。「巻き込まれない」ようにする道具です。

これは、性能ではなく設計の話です。 レポートが遅いのは仕様として許せます。ログイン画面が2秒待たされるのは許せません。 資源を分けるとは、「どれが遅くなってよいか」を先に決めておくことです。

さらに前へ進めるなら、前回のキューの型を使い分ける — システム設計深掘りでやったように、レポートはHTTPで同期処理せずキューへ逃がします。相手が外部サービスなら、落ちても全部は止めない — サーキットブレーカと縮退と組み合わせます。分ける・逃がす・諦める、の3つがセットです。


「うるさい隣人」はホスティングの世界でも同じ名前で呼ばれていて、共用のレンタルサーバーで他の利用者の重い処理に巻き込まれる現象を指します。JETBOYのように CloudLinux の準仮想化で他の利用者の影響を受けにくくし、プランごとに CPU コア数とメモリを割り当てるサーバーは、この節で言う「プールを分ける」発想をサーバー側でやっているものと読めます。ミニプランは年契約で月あたり 550 円・月契約 748 円に初期費用 1,100 円(税込・2026-11 時点、初期費用はキャンペーンで 550 円)で、最低利用期間は 3 ヶ月です。

⑦ 測らずに直す — この記事で一番大事な節

ここまでの①〜⑥は、全部「どこが遅いか分かっている」状態でやりました。実際には分かりません。

まず、遅いエンドポイントを作る

冒頭の一覧ページを、そのまま再現します。

bash
$ cat > ~/aplab/a7-guess.mjs <<'EOF'
  import mysql from 'mysql2/promise';
  import { DB, measure } from './lib/measure.mjs';
  const pool = mysql.createPool({ ...DB, connectionLimit: 10 });
  
  // 元の実装(3つの問題が同居している)
  async function feedV0() {
    const [posts] = await pool.query('SELECT * FROM posts ORDER BY id LIMIT 100'); // ← 余分な列
    for (const p of posts) {                                                        // ← N+1
      const [[a]] = await pool.query('SELECT * FROM authors WHERE id = ?', [p.author_id]);
      p.author = a.name;
    }
    const [[s]] = await pool.query('SELECT COUNT(*) AS n FROM posts');               // ← 追加の1本
    return { posts: posts.length, total: s.n };
  }
  await measure('⑦ 元の実装', 10, feedV0);
  await pool.end();
  EOF

$ node ~/aplab/a7-guess.mjs
⑦ 元の実装                    合計 5124.0ms  /  1回 512.40ms

512ミリ秒です。 ここで、私が実際にやった間違いをもう一度やります。

推測で直す(SELECT * を潰す)

bash
$ cat > ~/aplab/a7-guessfix.mjs <<'EOF'
  import mysql from 'mysql2/promise';
  import { DB, measure } from './lib/measure.mjs';
  const pool = mysql.createPool({ ...DB, connectionLimit: 10 });
  
  // 推測で直した版: SELECT * を全部やめただけ
  async function feedV1() {
    const [posts] = await pool.query(
      'SELECT id, title, author_id FROM posts ORDER BY id LIMIT 100');
    for (const p of posts) {
      const [[a]] = await pool.query('SELECT name FROM authors WHERE id = ?', [p.author_id]);
      p.author = a.name;
    }
    const [[s]] = await pool.query('SELECT COUNT(*) AS n FROM posts');
    return { posts: posts.length, total: s.n };
  }
  await measure('⑦ 推測で直した版', 10, feedV1);
  await pool.end();
  EOF

$ node ~/aplab/a7-guessfix.mjs
⑦ 推測で直した版               合計 5012.7ms  /  1回 501.27ms
時間改善
元の実装512.4ms—
SELECT * を全部やめた501.3ms2.2%

2.2%です。 ②で「439倍」を見たあとなので、効くはずだと思っていました。効きませんでした。

なぜ効かなかったのか — 測る

②で SELECT * が刺さったのは、10,000行を運んでいたからです。 ⑦の一覧は LIMIT 100 です。運んでいる量が100分の1なので、削れる量も100分の1でした。

同じアンチパターンでも、効くかどうかは「そこに何%あるか」で決まります。 それは測らないと分かりません。内訳を出します。

bash
$ cat > ~/aplab/a7-profile.mjs <<'EOF'
  import mysql from 'mysql2/promise';
  import { DB } from './lib/measure.mjs';
  const pool = mysql.createPool({ ...DB, connectionLimit: 10 });
  
  const acc = new Map();                     // ラベルごとに合計時間と回数を貯める
  async function q(label, sql, params) {
    const t = process.hrtime.bigint();
    const r = await pool.query(sql, params);
    const ms = Number(process.hrtime.bigint() - t) / 1e6;
    const e = acc.get(label) ?? { ms: 0, n: 0 };
    e.ms += ms; e.n++; acc.set(label, e);
    return r;
  }
  
  async function feed() {
    const [posts] = await q('一覧', 'SELECT id, title, author_id FROM posts ORDER BY id LIMIT 100');
    for (const p of posts) {
      const [[a]] = await q('著者名(1件ずつ)', 'SELECT name FROM authors WHERE id = ?', [p.author_id]);
      p.author = a.name;
    }
    await q('総件数', 'SELECT COUNT(*) AS n FROM posts');
  }
  
  const t0 = process.hrtime.bigint();
  await feed();
  const total = Number(process.hrtime.bigint() - t0) / 1e6;
  
  console.log('全体', total.toFixed(1), 'ms');
  console.log('---');
  for (const [k, v] of [...acc].sort((a, b) => b[1].ms - a[1].ms)) {
    const pct = (v.ms / total * 100).toFixed(1);
    console.log(`${k.padEnd(16)} ${v.ms.toFixed(1).padStart(7)}ms  ${String(v.n).padStart(3)}回  ${pct.padStart(5)}%`);
  }
  await pool.end();
  EOF

$ node ~/aplab/a7-profile.mjs
全体 511.8 ms
---
著者名(1件ずつ)     470.3ms  100回   91.9%
総件数              33.1ms    1回    6.5%
一覧                 5.2ms    1回    1.0%

91.9% が「1件ずつ著者名を引くループ」でした。

この30行が、この記事で一番役に立つコードです。 ライブラリも要りません。「呼ぶ場所を1つの関数にまとめて、ラベルと時間を貯めて、割合で並べる」だけです。

もう1つ見つかりました。SELECT COUNT(*) が 33ms で 6.5% です。 InnoDB は件数をどこにも持っていないので、COUNT(*) のたびに索引(あれば一番小さいもの)を端から端までたどって10,000行を数えていました。これは私がまったく疑っていなかった場所です。 推測では絶対に出てきません。

効く順に直す

91.9% の側から直します。

bash
$ cat > ~/aplab/a7-fixed.mjs <<'EOF'
  import mysql from 'mysql2/promise';
  import { DB, measure } from './lib/measure.mjs';
  const pool = mysql.createPool({ ...DB, connectionLimit: 10 });
  
  async function feedV2() {                       // ① 91.9% を潰す: JOIN 1回
    const [rows] = await pool.query(`
      SELECT p.id, p.title, a.name AS author
      FROM posts p JOIN authors a ON a.id = p.author_id
      ORDER BY p.id LIMIT 100`);
    const [[s]] = await pool.query('SELECT COUNT(*) AS n FROM posts');
    return { posts: rows.length, total: s.n };
  }
  
  async function feedV3() {                       // ② 6.5% を潰す: 主キーだけ数える
    const [rows] = await pool.query(`
      SELECT p.id, p.title, a.name AS author
      FROM posts p JOIN authors a ON a.id = p.author_id
      ORDER BY p.id LIMIT 100`);
    const [[s]] = await pool.query('SELECT COUNT(id) AS n FROM posts USE INDEX (PRIMARY)');
    return { posts: rows.length, total: s.n };
  }
  
  await measure('⑦ V2 (N+1を潰した)', 10, feedV2);
  await measure('⑦ V3 (件数も直した)', 10, feedV3);
  await pool.end();
  EOF

$ node ~/aplab/a7-fixed.mjs
⑦ V2 (N+1を潰した)            合計 401.2ms  /  1回 40.12ms
⑦ V3 (件数も直した)            合計 88.3ms  /  1回 8.83ms

まとめます。

版直したもの時間元からの改善
V0—512.4ms—
V1推測で SELECT * を全部501.3ms2.2%
V2測って分かった N+140.1ms12.8倍
V3V2 + 件数(6.5%の側)8.8ms58倍

同じ「30分」を、どこに使うかだけの違いです。 推測で使えば 2.2%。測ってから使えば 12.8倍。

順番を守る

V1(SELECT * を直す)が「無駄だった」わけではありません。 直しておいて損はありません。間違いは「先にやったこと」です。

  1. 全体を測る(512ms。ここが基準)
  2. 内訳を出す(91.9% / 6.5% / 1.0%)
  3. 一番大きいものを1つだけ直す
  4. もう一度、全体を測る(40ms)
  5. まだ足りなければ、2に戻る

3で「1つだけ」なのが要点です。 2つ同時に直すと、どちらが効いたのか永久に分かりません。

そして、ボトルネックは直すたびに移動します。 V2 の時点で、6.5% だった COUNT(*) は全体の82%になっていました。「次にどこを直すか」は、直すたびに測り直さないと分かりません。

この「まず測る」の順番と EXPLAIN の読み方は、本線の速くする前に必ず測る — パフォーマンス改善とEXPLAINにまとめてあります。アプリ側ではなくSQL1本ずつを追い込む方法は 遅いのはどのSQLか — SQL深掘りです。

スクリーンショットを撮ってください: 03_内訳と改善.png node a7-profile.mjs の内訳(91.9% の行が見えているもの)と、node a7-fixed.mjs の結果を並べて撮ってください。「2.2% と 58倍」が同じ画面にあるのが、この記事の結論です。


症状 → 疑う場所 → 確かめ方

最後に、この7つを「症状から引ける形」にまとめます。 手元に置いて使うのはこの表です。

症状まず疑うアンチパターン確かめ方(1コマンド)
件数が増えると比例して遅くなる(10件は速い、100件で10倍)① N+1(Chatty I/O)SQLを全部ログに出して本数を数える。件数と本数が連動したら確定
1本のSQLはどれも速いのに、全体が遅い① N+1SHOW GLOBAL STATUS LIKE 'Questions' を処理の前後で引いて差を見る
DBを別サーバーに分けたら遅くなった① N+1(往復時間が増えた)同上。回数 × 往復時間で説明が付くか計算する
CPUもDBも暇なのに遅い② 余分な取得(ネットワーク待ち)SHOW STATUS LIKE 'Bytes_sent' の増分。使った行数と比べる
アプリのメモリが処理中に跳ねる② 余分な取得取得直後の rows.length と、返した件数を並べて出す
軽いAPIまで一緒に遅い/全部が同時に遅い③ 同期I/O または ⑥ うるさい隣人/ping のような何もしないAPIを1本置いて、負荷中に ab で測る
平均は速いのに、たまに1〜2秒かかる③ 同期I/O(イベントループが塞がる瞬間)ab の 99% 行を見る。平均ではなく裾を見る
DBの接続数が処理量に比例して増える④ 毎回作り直すSHOW GLOBAL STATUS LIKE 'Connections' の増分
Too many connections で落ちる④(プール未使用)または ④のやりすぎ(プールが大きすぎ)SHOW PROCESSLIST で誰が何本握っているかを見る
DBのCPUだけ100%に張り付く⑤ Busy Databasedocker stats でDBのCPU。EXPLAIN に Using filesort / type: ALL が出るか
アプリのCPUだけ100%に張り付く⑤の逆(Busy Frontend)取得行数と、最終的に返した行数を比べる。捨てている割合を見る
重い機能を叩くと、無関係な機能が落ちる⑥ うるさい隣人資源(プール・スレッド)を用途ごとに分けて再測定する
直したのに、ほとんど速くならない⑦ 測らずに直した内訳を出す(a7-profile.mjs の形)。割合で並べる

上から3つは全部同じ①です。 症状の見え方が違うだけで、犯人は同じです。N+1は、初学者が踏むアンチパターンの半分以上を占めます。 ここだけ覚えて帰っても元は取れます。


つまずいたところ

1回目の測定だけ異常に遅い

measure() を書く前、単純に10回ループして平均を出していました。

① 直した版 (JOIN 1回)         1回 21.40ms

5.8ms のはずが 21ms です。 内訳を出したら、1回目だけ 160ms でした。接続の確立、MySQL側のバッファへの初回読み込み、Node.js の JIT が全部1回目に乗っています。

measure() が最初に await fn() を1回捨てているのはこのためです。 これを入れないと、「直した版のほうが遅い」という結論が普通に出ます。

「同じ結果が返っているか」を確かめずに比べていた

②で最初に書いた「直した版」は、created_at >= since を書き忘れていました。 当然速いです。取っているものが違うのだから比べる意味がありません。

この記事のコードが、どれも先に console.log('同じ結果か:', ...) を出しているのはそのためです。 速い版が同じ答えを返していないなら、それは最適化ではなくバグです。

ab が Connection reset by peer で止まる

③で同時数を上げすぎたときに出ました。

apr_socket_recv: Connection reset by peer (104)

サーバーが受け止めきれず切っています。 同時数を 10 まで下げたら安定しました。測定の道具が先に壊れているのに、それを「サーバーの限界」と読むのが一番危ない間違いです。 ab 側のエラー行が出ていないかを毎回確認してください。

⑥で /ping が 500 を返し始めた

プールを共有していた版で、レポートを 10本同時に投げたときです。

ER_CON_COUNT_ERROR

待ち行列が溢れて、接続の取得そのものが失敗しました。 遅くなるのを通り越して落ちています。

これがバルクヘッドの本当の理由です。 「遅くなる」なら我慢できますが、「レポートを叩くとログインが落ちる」は障害です。 記事では5本に減らして「遅くなる」段階を見せていますが、実運用では落ちるほうが先に来ます。

⑤で索引を張ったのに busyDb が速くならなかった

title に索引を張ってから測り直しましたが、1420ms のままでした。WHERE LOWER(title) LIKE '%記事%' は、索引を2重に殺しています。

  1. 列に関数(LOWER())を掛けている
  2. 前方一致でない('%…' で始まる)

索引は「列の値そのもの」で並んでいます。 加工した結果で探すなら、並んでいる意味がありません。「索引が効かない書き方をした」のであって、「索引が足りない」のではありませんでした。

COUNT(*) が遅いことに最後まで気づかなかった

⑦の 6.5% です。私は「件数を数えるだけだから一瞬」だと思い込んでいました。 実際は、呼ばれるたびに索引を端から端までたどって10,000行を数えていました。

思い込みは、測定結果の中にしか現れません。 内訳を出すまで、この行を疑ったことは一度もありませんでした。

数字が記事と一致しない

当然です。 VMのCPU、割り当てメモリ、ディスクがSSDかどうかで全部変わります。

大事なのは絶対値ではなく比です。

  • ① が10倍以上速くなっているか
  • ③ で /ping が2桁ミリ秒に収まっているか
  • ⑦ で「推測の改善」が1桁%、「測った改善」が1桁倍以上になっているか

この関係が再現していれば成功です。 逆に、①が2倍程度にしかならないなら、DBが同じマシンにあって往復時間が短すぎるのが理由です。それ自体が「①は距離が伸びるほど悪化する」の裏返しです。


後片づけ

この記事では 64MB のファイルと MySQL のコンテナを作っています。放置しないでください。

1. サーバープロセスを止める

端末1で Ctrl+C を押します。残っていないか確認します。

bash
$ ps aux | grep -E 'node .*(a3-sync|a6-noisy)' | grep -v grep

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

bash
$ kill <PID>

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

bash
$ ss -ltnp | grep -E ':3000|:3307'

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

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

bash
$ cd ~/aplab
$ docker compose down -v
[+] Running 2/2
 ✔ Container aplab-db      Removed
 ✔ Network aplab_default   Removed

-v を付けているので、1万件のデータごと消えます。

bash
$ docker ps -a | grep aplab-db

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

4. 64MB のファイルを消す

bash
$ ls -lh ~/aplab/big.bin
$ rm ~/aplab/big.bin

これは忘れやすいです。 VMのディスクを 64MB 食ったままになります。

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

bash
$ docker images | grep mysql
$ docker rmi mysql:8.0

本線の MySQL の回でも同じイメージを使っています。 そちらをまた使うなら残してください(約600MBあります)。

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

⑦のプロファイル用コード(a7-profile.mjs)は、今後も使えます。 残す価値があります。消すなら:

bash
$ cd ~
$ rm -rf ~/aplab

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

7. 最後の確認

bash
$ docker ps
$ df -h /
$ free -h

aplab-db が無く、ディスクとメモリが元に戻っていれば完了です。


まとめ — 理解できたこと

  • 「遅いアプリ」の書き方には名前が付いている。 N+1、余分な取得、同期I/O、毎回の生成、Busy Database、うるさい隣人。名前を知っていれば、書く前に避けられる
  • 1回が速いことは、全体が速いことを何も保証しない。 悪い版のSQLは1本 1.5ms で、JOIN 1本の 5.8ms より速かった。それでも 26倍遅かった。効くのは 回数 × 往復時間
  • N+1は「遅いSQLを探す道具」では絶対に見つからない。 1本ずつは全部速いので、slow_query_log に1本も乗らない。数えるのはSQLの本数
  • N+1はDBを別サーバーに分けた瞬間に悪化する。 アプリを1行も変えていないのに遅くなる。往復時間が増えるから
  • 絞り込みはデータの近くでやるほど速い。 10,000行・14.2MB を運んで4行だけ使った版と、DBで絞った版で 439倍。索引を足してさらに 4.5倍
  • SELECT * が罪なのではない。 罪は「要らない行を運んだこと」と「要らない列を運んだこと」。⑦では同じ SELECT * を潰しても 2.2% しか効かなかった
  • Node.js の同期I/Oは、そのリクエストだけを遅くするのではない。 readFileSync 1行で、無関係な /ping が 9.6ms → 742ms(77倍)。ログには「/ping が遅い」としか出ない
  • 接続は張り直すたびに金を払う。 毎回 createConnection する版とプールで 24倍。23msのうち、SQLは 0.3ms 未満で残りは全部、接続を張る作業だった
  • データベースは、システムの中で一番増やしにくい部品。 アプリのCPUは増やせる資源、DBのCPUは増やせない資源。増やせない側で燃やしていいのは、そこでしかできない仕事だけ
  • 境界線は「DBかアプリか」ではなく「索引で消せる仕事か」。 索引で消せる並べ替えをアプリでやったら 333倍遅かった。逆に索引を殺す書き方でDBにやらせたら 33倍遅かった。両側に落とし穴がある
  • バルクヘッドは速くする道具ではなく、巻き込まれない道具。 プールを分けたら /ping が 2050ms → 4.8ms。レポート自体はむしろ遅くなった。「どれが遅くなってよいか」を先に決めるのが設計
  • そして一番大事なこと: 推測で直した箇所は、全体の 2.2% しか占めていなかった。 同じ30分を、測ってから使えば 12.8倍、2周目まで回して 58倍だった
  • 内訳を出すのに、道具は要らない。 呼ぶ場所を1つの関数にまとめて、ラベルと時間を貯めて、割合で並べる 30行。それだけで 91.9% の犯人が出た
  • 一度に直すのは1つだけ。 2つ同時に直すと、どちらが効いたのか永久に分からない。そして直すたびにボトルネックは移動する(6.5%だった COUNT(*) が、次の周では 82% になっていた)

参考リンク


次に読む

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

記事
← 前の記事イベント駆動アーキテクチャ — 機能を足すたび注文APIが壊れる
→ 次の記事サービスディスカバリと名前解決 — 相手のIPを書いたら翌日壊れた

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

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

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

System Design›System Design — Performance Antipatterns
  • N+1・取りすぎ・同期I/O・毎回生成
  • 測らずに直さない

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

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

コメント

コメントする

目次