速くする前に必ず測る — パフォーマンス改善とEXPLAIN

パフォーマンス改善。アプリ画面とデータベース、ストップウォッチと実行計画の書類。

「なんか遅い」を心当たりで直すと当たりません。フロントとデータベースを別々に測り、EXPLAINで裏を取る順番を決めます。

前回: まだマイクロサービスにしない — モノリスと12 Factor 作業場所はVMの中(Ubuntu)です。ここまでで作った ~/server(API)と ~/react-demo(フロント)を、そのまま使います。

「なんか遅いんですけど」と言われたとき、一番やってはいけないのがこれです。

「たぶんデータベースかな……」と思って、心当たりのあるSQLを書き直す。

当たることもあります。 ただ、当たったかどうかも分かりません。直す前の数字が無いからです。

この回でやるのは、その順番を変えることです。

測る → 一番遅いところを1つだけ直す → もう一度測る。

Redis の回で「入れる前に必ず測る」をやりました。あれと同じ型を、今度はフロントとバックの両方に広げます。 そして、Redis の回で扱えなかったほう —— 索引を張れば直る遅さ —— を、今回の山場にします。

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

目次

この記事でわかること

  • 体感の遅さは、たいてい1箇所で決まること。全部を少しずつ速くしても体感は変わらないこと
  • フロントとバックでは、測る道具がまったく違うこと。同じ「遅い」でも見る場所が別だということ
  • 開発サーバーで測った数字は当てにならないこと。ビルド済みの dist/ を配って測らないと意味がないこと
  • EXPLAIN を読めば「全部読んでいる」が目で見えること。索引はコピペで張るものではないこと
  • キャッシュは最後の手段で、先にやると遅い原因が隠れたまま残ること
  • 測って許容範囲なら直さない、という判断があること

この記事でやること

  1. フロントを測る。 npm run build した dist/ を配って、開発者ツールの Network と Lighthouse で見る
  2. バックを測る。 リクエスト1本の処理時間をログに出し、どこで時間を使っているか分解する
  3. わざと遅いクエリを作り、EXPLAIN で全件走査を確認し、索引を張って直して測り直す
  4. N+1問題を実際に作って、問い合わせが101回飛んでいることをログで見て、1回に直す
  5. 直さない判断をする。 目標値を決めて、それを下回っているものは触らない

先に知る言葉

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

言葉意味
ボトルネック全体の速さを決めてしまっている1箇所。 瓶の首。ここ以外を速くしても全体は変わらない
プロファイリングどこで時間を使っているかを実際に測って分解すること。推測の反対語
レイテンシ / スループットレイテンシ=1本にかかる時間、スループット=1秒に何本さばけるか。別のもので、片方だけ良いことがある
TTFBTime To First Byte。リクエストを出してから、最初の1バイトが返ってくるまで。 ここが長い=サーバー側が遅い
ウォーターフォール開発者ツールの Network に出る滝のような横棒のグラフ。 どれがいつ始まって、いつ終わったかが分かる
p50 / p95速い順に並べたときの真ん中(p50)と、遅いほうから5%目(p95)。平均は嘘をつくので使わない
索引(インデックス)「この値ならこの行」という早見表。 本の巻末の索引と同じ。全部を読まずに目的の行へ行ける
フルスキャンテーブルの全行を上から読むこと。 索引が使えないとこうなる
EXPLAINそのSQLをMySQLがどう実行するつもりかを出させる命令。実行はしない
N+1問題一覧を1回引いたあと、その1件ごとに追加で問い合わせてしまうこと。100件なら101回
スロークエリログ一定時間より遅かったSQLだけを書き出してくれるMySQLの機能

「プロファイリング」という言葉が、この記事の全部です。 推測でチューニングしない。 分解して、数字で一番大きいものを見つけて、そこだけ直す。それ以外はやらない。

体感の遅さは、たいてい1箇所で決まる

まず、この記事全体の土台になる考え方です。

あるページの表示に 1000ms かかっていたとします。 内訳がこうだったとします。

何に時間
HTMLを受け取る30ms
JSとCSSを読む60ms
APIの応答を待つ820ms
画面を組み立てる90ms

ここで、JSを頑張って半分にしたとします。 60ms → 30ms。全体は 1000ms → 970ms。

3%です。誰も気づきません。

一方、820ms のAPIを 100ms にできたら、全体は 280ms になります。 体感で言えば「別のサイト」です。

速くするのは1箇所でいい。 問題は、その1箇所がどこか、測らないと分からないことです。 そして人間の勘は、ほぼ当たりません。 自分が最近書いたところ、自分が難しいと思っているところを疑ってしまうからです。

この記事でやることは、要するに「820ms がどこにあるかを探す作業」です。

平均を見ない

もう1つだけ、先に。「平均 200ms です」は、ほとんど情報がありません。

100回のうち95回が 50ms、5回が 3000ms でも、平均は 197ms になります。そして、遅いと文句を言ってくるのは、その5回を踏んだ人です。

見るのは p50(真ん中)と p95(遅いほうから5%目)です。p95 が悪いのに平均が良い、はよくあります。 この記事では最後まで手で測るので p50 / p95 は出しませんが、監視の回で自動的に取る話に繋がります。 言葉だけ覚えてください。

測る道具は、フロントとバックで別

同じ「遅い」でも、見る場所が違います。 ここを混ぜると、永遠に見つかりません。

どこが遅いか使う道具見る数字
ブラウザ側(読み込み・描画)開発者ツールの Network / Lighthouse転送量、リクエスト数、LCP
通信そのもの開発者ツールの Network、curl -wTTFB
サーバー側(アプリの処理)自分で仕込むログ処理時間の内訳
データベースEXPLAIN、スロークエリログ読んだ行数、実行時間

切り分けの起点は1つだけです。

開発者ツールの Network で、そのAPIの TTFB を見る。 TTFB が長ければサーバー側。短いのに画面が遅ければブラウザ側。

開発者ツールの回で「ページが重いときは Network の Time 列」と書きました。あれが、この記事の入口です。

① フロントを測る

開発サーバーの数字は、当てにならない

先にここを潰します。 これを知らないと、以降の測定が全部無駄になります。

bash
$ cd ~/react-demo
$ npm run dev -- --host 0.0.0.0

この状態で Network タブを開くと、ファイルが何十本も並びます。 そして遅く見えます。でも、それは本番と何の関係もありません。

npm run devnpm run build した dist/
ファイルの配り方1ファイルずつ、そのまままとめて1〜数本(バンドル)
中身人が読める形のままminify 済み(改行も変数名も削られている)
余計なものHMR のクライアントが乗っている無い
圧縮基本かからないnginx が gzip で送る

ビルドツールの回でやった話が、そのまま効いてきます。

開発サーバーは「速く書き換えるため」の道具で、「速く配るため」の道具ではありません。 測るときは、必ず npm run build してから測ります。

bash
$ cd ~/react-demo
$ npm run build
$ npm run preview -- --host 0.0.0.0

npm run preview は、dist/ をそのまま配るだけのサーバーです。Windows側のブラウザから http://VMのIP:4173/ を開いてください(IPは VM の中で ip a で確認できます)。

[スクリーンショット: 01_devとbuildの比較.png] Network タブを2枚並べて(または上下に)、npm run dev のときのリクエスト一覧と、npm run preview のときのリクエスト一覧を撮ってください。リクエストの本数と、一番下に出る合計転送量の差が読めることが条件です。

「本番でも nginx で配る」なら、nginx で測ってください。 nginx の回でやったとおり、dist/ を置けばそのまま配れます。npm run preview は本番と完全には同じではありません(圧縮の設定などが違います)。

Network タブで見る4つ

再読み込みして、この4つだけ見ます。

見るものどこ意味
リクエストの本数一番下のバー多いほど、待ちが積み上がる
転送量(transferred)一番下のバー実際に回線を流れた量。 圧縮後の数字
Size 列各行どのファイルが重いのか。 ここでソートする
Time 列 / ウォーターフォール各行どれが長いか。 そして何を待って始まっていないか

必ず先に2つチェックを入れてください。

  • Disable cache … これを入れないと2回目以降が全部キャッシュから返り、速く見えます。初めて来た人の数字が測れません
  • No throttling を Fast 3G に変える(新しい版の Chrome には Fast 3G が無く、同じ速さの設定が Slow 4G という名前になっています) … 手元は速すぎます。遅い回線にしないと差が見えません

レスポンシブの回でデバイスツールバーを使いました。 あれと同じ場所の話です。画面の幅だけでなく、回線も本番のほうに寄せます。 スマホで見られるサイトなら、Fast 3G(Slow 4G)の数字のほうが本当の数字です。

そして Size 列でソートしてください。 ほぼ確実に、上に来るのはこの2つです。

一番重いのは、たいてい画像とフォント

JavaScript ではありません。 これは実際に確かめられます。

~/react-demo/public/ に、スマホで撮った写真をそのまま1枚置いてください。 加工しないでください。それがまさに事故の形だからです。

bash
$ cd ~/react-demo/public
$ ls -lh

3〜5MB あるはずです。 src/App.jsx のどこかに、そのまま貼ります。

<img src="/photo.jpg" alt="テスト用の写真" />
bash
$ cd ~/react-demo
$ npm run build
$ npm run preview -- --host 0.0.0.0

もう一度 Network を見てください。 JS と CSS が合わせて数十KBなのに対し、写真1枚が数MBです。

dist/assets/index-xxxx.js を 10KB 削る努力と、写真1枚を 4MB → 200KB にする作業は、効果が20倍以上違います。 にもかかわらず、前者のほうが「技術的で偉い作業」に見えます。 ここが罠です。

直します。 画像を扱う道具を入れます。

bash
$ sudo apt update
$ sudo apt install -y imagemagick webp
bash
$ cd ~/react-demo/public
$ identify photo.jpg
photo.jpg JPEG 4032x3024 4032x3024+0+0 8-bit sRGB 4.21MB 0.000u 0:00.000

4032x3024。 表示しているのは、どう大きくても画面幅 1200px 程度です。4032px は、そのまま捨てられています。

bash
$ convert photo.jpg -resize 1200x -quality 80 photo-1200.jpg
$ cwebp -q 80 photo.jpg -o photo.webp
$ ls -lh photo.jpg photo-1200.jpg photo.webp
-rw-rw-r-- 1 user user 4.3M Sep  6 10:12 photo.jpg
-rw-rw-r-- 1 user user 168K Sep  6 10:13 photo-1200.jpg
-rw-rw-r-- 1 user user 121K Sep  6 10:13 photo.webp

4.3MB が 121KB。 見た目はほとんど変わりません。

convert が「command not found」なら magick photo.jpg -resize 1200x -quality 80 photo-1200.jpg を試してください。 ImageMagick は版によってコマンド名が違います。

画像は、もう1つやることがあります。

<img src="/photo-1200.jpg" alt="テスト用の写真" width="1200" height="900" loading="lazy" />
属性何のため
width / height場所を先に確保する。 無いと、画像が来た瞬間に下の文章がガクッと動く
loading="lazy"画面に入るまで読み込まない。 ページの下のほうの画像に効く

loading="lazy" を、一番上の大きな画像に付けないでください。 最初に見える画像の表示が、逆に遅くなります。

フォントも同じ話です。 Network の Font で絞り込んでください。

日本語のWebフォントは、1ファイルで数MBあります。 英数字だけのフォントの何十倍です。 文字の形を全部持っているからで、これは削れません。サブセット(使う文字だけ抜き出す)か、そもそも使わないかの二択になります。 CSSの回で書いた font-family にOSの標準フォントを並べるだけなら、転送量はゼロです。

Lighthouse — 点数を上げるゲームにしない

Chrome の開発者ツールに Lighthouse タブがあります。 npm run preview のURLを開いた状態で、Analyze page load を押します。

出てくるものは2種類あります。

出るもの扱い
Opportunities(改善の余地)
新しい版では Insights
「これを直すと何ms速くなる」と書いてある。 ここだけ読む
総合スコア(0〜100)参考。追いかけない

スコアを100にするのは、目的になりません。 スコアは実行するたびに数点ぶれますし、「点数のために表示を遅くする」逆転も普通に起きます。見るのは Opportunities に並んだ ms のほうです。(Lighthouse 13 以降は、この欄が Insights にまとめ直されています。画面の名前が違っても、見るのは「直すと何が速くなるか」の欄です)

そして、Lighthouse には条件があります。

  • ビルド済みを測る(npm run dev に対して実行しても意味がありません。この記事の最初の話です)
  • 拡張機能が結果を汚す。 シークレットウィンドウで実行してください
  • 2〜3回走らせて、真ん中を取る

[スクリーンショット: 02_lighthouse結果.png] Lighthouse の結果画面で、Opportunities の一覧が読める状態を撮ってください。写真を貼ったあとに実行すると、画像に関する指摘が上に出てきます。

LCP(Largest Contentful Paint)という言葉が出てきます。 「一番大きいものが表示されるまでの時間」です。多くのページで、その「一番大きいもの」は画像です。 ここでも画像が主役になります。

② バックを測る — 時間の使い道を分解する

フロントを測ったら、次はサーバー側です。 道具がまったく変わります。開発者ツールは、サーバーの中身を見せてくれません。

まず、外から測る

Redis の回で使った curl -w を、もう少し細かくします。

bash
$ cd ~/server
$ node --env-file=.env app.js

別のターミナルで、ログインしてから測ります。

bash
$ cd ~/server
$ curl -s -c cookie.txt -X POST http://localhost:3000/api/login \
    -H "Content-Type: application/json" \
    -d '{"email":"me@example.com","password":"pass12345"}' > /dev/null

$ curl -o /dev/null -s -b cookie.txt \
    -w "接続:%{time_connect}s  最初の1バイト:%{time_starttransfer}s  合計:%{time_total}s\n" \
    http://localhost:3000/api/tasks
接続:0.000138s  最初の1バイト:0.041902s  合計:0.042051s
数字意味
time_connect繋がるまで。 ここが長い=ネットワークの問題
time_starttransferTTFB。 ここが長い=サーバーが考えている
time_total全部終わるまで。TTFB との差が大きい=返しているデータが大きい

この3つの差を見るだけで、切り分けが1段階進みます。 TTFB が長い → サーバーの中。TTFB は短いのに合計が長い → 返す量が多い。

中を測る — 全リクエストの処理時間をログに出す

外から測っても「サーバーの中が遅い」までしか分かりません。 ここから中に入ります。

一番簡単で、一番効くのがこれです。 ~/server/app.js の、ルートを書いている場所より前に足します。

app.use((req, res, next) => {
  const start = process.hrtime.bigint();
  res.on("finish", () => {
    const ms = Number(process.hrtime.bigint() - start) / 1e6;
    console.log(`[${res.statusCode}] ${req.method} ${req.originalUrl} ${ms.toFixed(1)}ms`);
  });
  next();
});
書いたものなぜ
app.use をルートより上に置く下に置くと、そのルートを通らない。順番に意味があります
res.on("finish")返し終わった瞬間に鳴る。ここで測らないと「返す時間」が抜ける
process.hrtime.bigint()Date.now() より細かい(ナノ秒)。ミリ秒単位の話には足りません

サーバーを立て直して、いくつか叩いてください。

[200] GET /api/tasks 41.8ms
[200] GET /api/stats 268.3ms
[304] GET /api/tasks 3.1ms

これだけで、「どのURLが遅いか」が全部見えます。 遅いページを探して回る必要がなくなります。 本番でも、これは入れっぱなしにします。 監視の回で扱ったログの話と、そのまま繋がります。

さらに中を分解する — 受け取り / DB / 外部API / 返す

「この1本が 268ms」まで来たら、次はその内訳です。 リクエスト1本は、だいたいこの4つでできています。

段何をしている遅いときの原因
受け取りボディを読む、認証を確かめる巨大なJSONを受けている、認証のたびにDBを引いている
DBSQLを投げて待つ索引が無い、N+1(この記事の主役)
外部API他所のサーバーを待つ相手が遅い。自分では直せない
返すJSONに直して送る返す件数が多すぎる(全件返している)

測り方は、身も蓋もない方法で構いません。

app.get("/api/report", requireLogin, async (req, res) => {
  const t0 = process.hrtime.bigint();

  const tasks = await knex("tasks").where({ user_id: req.session.userId }).limit(100);
  const t1 = process.hrtime.bigint();

  const weather = await fetch("https://example.com/").then((r) => r.text());
  const t2 = process.hrtime.bigint();

  const body = tasks.map((t) => ({ id: t.id, title: t.title }));
  const t3 = process.hrtime.bigint();

  const ms = (a, b) => (Number(b - a) / 1e6).toFixed(1);
  console.log(`DB=${ms(t0, t1)}ms 外部API=${ms(t1, t2)}ms 整形=${ms(t2, t3)}ms`);

  res.json(body);
});
DB=12.4ms 外部API=241.7ms 整形=0.3ms

これで「DBだと思っていたら外部APIだった」が一発で分かります。 実際、これは非常によくあります。 外部APIが遅いなら、SQLをいくら磨いても1msも速くなりません。 できるのは、並行して呼ぶ(非同期処理の回の Promise.all)か、キャッシュするか、そもそも呼ばないかです。

泥臭く見えますが、これが正解です。 立派なプロファイラを入れる前に、まず console.log で内訳を出す。 ここで9割の犯人は捕まります。

スロークエリログ — MySQLに告白させる

DBが怪しいと分かったら、MySQL 自身に吐かせます。

bash
$ sudo mysql
SET GLOBAL slow_query_log = 'ON';
SET GLOBAL long_query_time = 0.2;
SELECT @@slow_query_log_file;
+---------------------------------+
| @@slow_query_log_file           |
+---------------------------------+
| /var/lib/mysql/ubuntu-slow.log  |
+---------------------------------+

exit して、別のターミナルで流しておきます。

bash
$ sudo tail -f /var/lib/mysql/ubuntu-slow.log

この状態でAPIを叩くと、0.2秒を超えたSQLだけが流れてきます。

SET GLOBAL はMySQLを再起動すると消えます。 練習ではそのほうが安全です。設定ファイルに書くのは、本当に常時必要になってからで構いません。 本番で long_query_time を 0 にしないでください。 全部のクエリが書かれてディスクが埋まります。

③ 索引を張れば直る遅さ

ここがこの記事の中心です。

Redis の回では、索引を張っても直らない遅さを扱いました。20万行すべてが user_id = 1 だったので、読み飛ばす行が1行も無かったからです。

今回は逆です。索引で直るほうをやります。 そして、その2つを見分けられるようにします。

遅い状態を、もう一度作る

Redis の回の後片づけでダミーを消しているので、入れ直します。

bash
$ sudo mysql
SET SESSION cte_max_recursion_depth = 1000000;

INSERT INTO appdb.tasks (title, user_id)
WITH RECURSIVE seq AS (
  SELECT 1 AS n
  UNION ALL
  SELECT n + 1 FROM seq WHERE n < 200000
)
SELECT CONCAT('ダミー', n), 1 FROM seq;

今回は title がすべて違う値になっています。 ダミー1 から ダミー200000 まで、同じものが1つもありません。 ここが前回との違いです。

SELECT COUNT(*) FROM appdb.tasks;
+----------+
| COUNT(*) |
+----------+
|   200003 |
+----------+

タイトルで1件だけ探す

「タイトルで検索する」という、ごく普通の機能を想定します。

SELECT id, title FROM appdb.tasks WHERE title = 'ダミー150000';
+--------+------------------+
| id     | title            |
+--------+------------------+
| 150003 | ダミー150000     |
+--------+------------------+
1 row in set (0.09 sec)

1行を取り出すのに 0.09 秒。 20万件でこれなら、200万件では約0.9秒です。件数に正比例して遅くなります。

1 row in set (0.09 sec) の括弧の中を、必ず見る癖をつけてください。 MySQLは毎回これを出しています。

EXPLAIN で「何をするつもりか」を見る

なぜ遅いのか。推測しません。MySQLに聞きます。

EXPLAIN SELECT id, title FROM appdb.tasks WHERE title = 'ダミー150000';
+----+-------------+-------+------+---------------+------+---------+------+--------+----------+-------------+
| id | select_type | table | type | possible_keys | key  | key_len | ref  | rows   | filtered | Extra       |
+----+-------------+-------+------+---------------+------+---------+------+--------+----------+-------------+
|  1 | SIMPLE      | tasks | ALL  | NULL          | NULL | NULL    | NULL | 199243 |    10.00 | Using where |
+----+-------------+-------+------+---------------+------+---------+------+--------+----------+-------------+

EXPLAIN は実行しません。「こう実行するつもりだ」を答えるだけです。安全に何度でも打てます。

列は12個ありますが、最初に見るのは3つだけです。

列この結果意味
typeALL最悪の値。 「全部読む」という宣言
keyNULL索引を1つも使っていない
rows199243読むつもりの行数の見積もり。 1行取るために20万行読む

type: ALL と key: NULL と rows が大きい。 この3点セットが揃ったら、索引の話です。

type は、良いほうから並べるとこうなります。

type意味
const / eq_ref主キーなどで1行に決まる。 最速
ref索引で絞れている。 ここを目指す
range索引を使って範囲で絞っている(BETWEEN など)。十分良い
index索引を頭から最後まで舐めている。 ALL よりましなだけ
ALLフルスキャン。 直す対象

[スクリーンショット: 03_explain_全件走査.png] EXPLAIN の結果で、type が ALL、key が NULL、rows が約20万になっている行が読めるように撮ってください。

索引を張る

exit して、マイグレーションの回でやったとおりに張ります。 手で ALTER TABLE を打ちません。

bash
$ cd ~/server
$ node --env-file=.env.migrate node_modules/knex/bin/cli.js migrate:make add_index_title
$ nano ~/server/migrations/*_add_index_title.js
exports.up = function (knex) {
  return knex.schema.alterTable("tasks", (t) => {
    t.index("title", "idx_tasks_title");
  });
};

exports.down = function (knex) {
  return knex.schema.alterTable("tasks", (t) => {
    t.dropIndex("title", "idx_tasks_title");
  });
};
bash
$ node --env-file=.env.migrate node_modules/knex/bin/cli.js migrate:latest

20万行への索引作成は、数秒かかります。 練習では一瞬ですが、本番の大きなテーブルでは、その間テーブルが重くなります。 「索引を張るのは無料」ではありません。

もう一度 EXPLAIN

bash
$ sudo mysql
EXPLAIN SELECT id, title FROM appdb.tasks WHERE title = 'ダミー150000';
+----+-------------+-------+------+-----------------+-----------------+---------+-------+------+----------+-------+
| id | select_type | table | type | possible_keys   | key             | key_len | ref   | rows | filtered | Extra |
+----+-------------+-------+------+-----------------+-----------------+---------+-------+------+----------+-------+
|  1 | SIMPLE      | tasks | ref  | idx_tasks_title | idx_tasks_title | 1023    | const |    1 |   100.00 | NULL  |
+----+-------------+-------+------+-----------------+-----------------+---------+-------+------+----------+-------+

3つとも変わりました。

前後
typeALLref
keyNULLidx_tasks_title
rows1992431

199243 行 → 1 行。 これが索引です。

SELECT id, title FROM appdb.tasks WHERE title = 'ダミー150000';
1 row in set (0.00 sec)

0.09秒 → 0.00秒。 そして重要なのは、200万件に増えても、この 1 は 1 のままだということです。

索引の本当の価値は「いま速いこと」ではなく、「増えても遅くならないこと」です。 フルスキャンは件数に比例して遅くなります。索引はほとんど増えません(正確には件数の対数で増えます)。運用していて突然遅くなるのは、たいていここです。

[スクリーンショット: 04_explain_索引あり.png] 索引を張ったあとの EXPLAIN で、type: ref と rows: 1 が読めるように撮ってください。03 と並べると、この記事で一番はっきりした変化です。

張った索引の一覧は、こう見ます。

SHOW INDEX FROM appdb.tasks;

索引は無料ではない

「じゃあ全部の列に張ればいい」——これが次の事故です。

代金内容
書き込みが遅くなるINSERT / UPDATE のたびに、索引も全部書き換わる。索引10本なら10本分
容量を食う索引は実体を持つデータ。テーブルより索引のほうが大きい、も普通に起きる
使われないこともある張っただけでは意味がない。 EXPLAIN で使われていることを必ず確認する

そして、張ったのに効かない書き方があります。

書き方索引が
WHERE title = 'x'効く
WHERE title LIKE 'ダミー%'効く(前方一致)
WHERE title LIKE '%150000'効かない(後方・部分一致。先頭が分からないと早見表を引けない)
WHERE CHAR_LENGTH(title) = 12効かない(列に関数を掛けると、索引の値と別物になる)
WHERE user_id = 1 AND done = 02列まとめた索引(複合索引)が要る。片方ずつ張っても片方しか使われないことが多い

LIKE '%キーワード%' は、索引では速くなりません。 全文検索の仕組み(MySQLなら FULLTEXT)か、専用の検索エンジンの話になります。そこまで来たら、それは別の道具の出番です。 確かめ方は1つだけです。EXPLAIN を打つ。 「効くはず」で終わらせないでください。

Redis の回と、どう見分けるか

同じ「遅い」でも、直し方が違います。 ここが今回いちばん持ち帰ってほしい表です。

症状EXPLAIN の見え方直し方
少数の行を探すのに全件読んでいるtype: ALL、rows が大きい、結果は数行索引(今回)
本当に大量の行を集計しているrows が大きい、結果も全行が対象キャッシュ(Redis の回)
同じ問い合わせが何度も来る1本は速いが、回数が多いキャッシュ、または呼ぶのをやめる
1本1本は速いのに合計が遅いどれも rows: 1N+1(次の節)

判断の分かれ目は、rows(読む行数)と、返ってくる件数の差です。 20万行読んで1行返す → 読みすぎ。索引で直る。 20万行読んで20万行を合計する → 読む量は減らせない。キャッシュの出番。

④ N+1問題 — 1本1本は速いのに、遅い

EXPLAIN がどれも rows: 1 なのに、APIは遅い。 これが起きたら、疑うのは1つです。

わざと作る

~/server/app.js に足します。まず、SQLが何本飛んだか数えられるようにします。

let queryCount = 0;
knex.on("query", () => {
  queryCount++;
});
app.get("/api/tasks/withuser", requireLogin, async (req, res) => {
  queryCount = 0;
  const t0 = process.hrtime.bigint();

  const tasks = await knex("tasks").select("id", "title", "user_id").limit(100);

  const out = [];
  for (const t of tasks) {
    const user = await knex("users").where({ id: t.user_id }).first();
    out.push({ id: t.id, title: t.title, email: user.email });
  }

  const ms = Number(process.hrtime.bigint() - t0) / 1e6;
  console.log(`SQL ${queryCount}本 / ${ms.toFixed(1)}ms`);
  res.json(out);
});

queryCount はサーバー全体で1つの変数なので、同時に何本もリクエストが来ると数字が混ざります。 今は1本ずつ手で叩いて測るので、これで足ります。 本番でこの形にはしません。

bash
$ curl -s -b cookie.txt http://localhost:3000/api/tasks/withuser > /dev/null

サーバー側のログを見てください。

SQL 101本 / 214.6ms
[200] GET /api/tasks/withuser 215.9ms

101本。 一覧に1本、そのあと100件それぞれに1本ずつです。これが N+1 という名前の由来です。

1本あたり2msでも、101本で202ms。 そして EXPLAIN を打つと、どれも rows: 1 の完璧なクエリです。1本ずつ見ている限り、絶対に見つかりません。

[スクリーンショット: 05_n1のログ.png] SQL 101本 と出ているログを撮ってください。101 という数字が読めることが条件です。

直す

やることは1つです。100回に分けて聞いていたものを、1回で聞きます。

app.get("/api/tasks/withuser", requireLogin, async (req, res) => {
  queryCount = 0;
  const t0 = process.hrtime.bigint();

  const rows = await knex("tasks")
    .join("users", "users.id", "tasks.user_id")
    .select("tasks.id", "tasks.title", "users.email")
    .limit(100);

  const ms = Number(process.hrtime.bigint() - t0) / 1e6;
  console.log(`SQL ${queryCount}本 / ${ms.toFixed(1)}ms`);
  res.json(rows);
});
SQL 1本 / 4.2ms

101本 → 1本。214ms → 4ms。 50倍です。SQLは1文字も速くしていません。回数を減らしただけです。

JOIN が使えない場合(別のテーブルにまとめたくない、別のサービスにある、など)は、まとめて引いてから紐づけます。

const tasks = await knex("tasks").select("id", "title", "user_id").limit(100);

const ids = [...new Set(tasks.map((t) => t.user_id))];
const users = await knex("users").whereIn("id", ids).select("id", "email");
const byId = new Map(users.map((u) => [u.id, u]));

const out = tasks.map((t) => ({ id: t.id, title: t.title, email: byId.get(t.user_id).email }));

これでも 2本です。[...new Set(...)] で重複を消しているのが要点で、同じユーザーが何度出てきても、聞くのは1回です。

whereIn に渡すIDが数千個になると、今度はそのSQLが重くなります。 数百ずつに区切って投げるのが定石です。「1回にまとめる」も、やりすぎると別の問題になります。

なぜ気づかないのか

このコードは、読むと自然です。

for (const t of tasks) {
  const user = await knex("users").where({ id: t.user_id }).first();
}

「タスクごとに、その人を取ってくる」。日本語にすると、まったく正しい。

N+1は、コードが間違っているから起きるのではありません。 ループの中に問い合わせがある、という形から起きます。 見つけ方は形で覚えます。「ループの中の await で、DBか外部APIを呼んでいないか」。 これだけです。

そしてORMの回で書いたことが、ここで効いてきます。

ORM を使うと、task.user.email と書いた瞬間に裏でSQLが飛ぶことがあります(遅延読み込み)。コードにSQLが1文字も見えないので、101本飛んでいることに気づけません。 だから、SQLの本数を数えるログを持っておく価値があります。

⑤ キャッシュは最後の手段

ここまでの4つを飛ばして、いきなりキャッシュを入れるとどうなるか。

遅い原因が、直らないまま、見えなくなります。

索引の無いクエリにキャッシュを被せると、こうなります。

  • キャッシュが当たっている間は速い
  • 外れた1回は、相変わらず 0.09 秒かかる
  • 再起動やデプロイでキャッシュが空になると、その遅いクエリが一斉に走る
  • そして、原因を調べようとしても、もう遅いところが見えない

順番はこうです。

順やることこの記事の場所
1測る。どこが遅いか特定する①②
2回数を減らす(N+1を潰す)④
31回を速くする(索引)③
4返す量を減らす(全件返さない、画像を小さくする)①
5それでも遅ければ、キャッシュRedis の回

キャッシュは、「読む量そのものを減らせない」と分かったときにだけ使います。 Redis の回で書いた「入れる条件5つ」——測った / 索引で直らない / 何度も引かれる / 古くても平気 / 消す場所を書き出せる——を、必ず先に通してください。

ちなみに、返す量を減らすのは軽視されがちですが、効きます。

const rows = await knex("tasks").select("*");

SELECT * は、使わない列まで全部読んで、JSONに直して、回線に流します。 使う列だけ書けば、それだけで小さくなります。REST APIの回でやったページングも、まったく同じ目的です。

⑥ やりすぎない —— 直さない、という判断

最後に、一番大事な話をします。

測ると、必ず「遅いもの」が見つかります。 そして、直したくなります。 でも。

目標を決めていない改善は、終わりません。

先に線を引きます。 例えばこうです。

対象目標超えたら
API 1本の応答200ms 以内調べる
画面が出るまで(Fast 3G / Slow 4G)3秒以内調べる
1ページの転送量1MB 以内調べる

この数字はあなたが決めるもので、正解はありません。大事なのは、決まっていることです。

50ms のAPIを 30ms にする作業には、価値がありません。 誰も気づかないからです。 その時間で、まだ書いていない機能を書くか、テストを書くほうが、ほぼ確実に得です。

「速くする」より「遅くならないよう見張る」

そして、パフォーマンス改善の本当の姿はこれです。

一度速くしても、放っておけば必ず遅くなります。 データが増えるからです。機能が増えるからです。そして、遅くなったことに気づくのは、たいてい利用者です。

やり方結果
遅くなってから、原因を探して直す毎回、この記事の全部をやり直す
常に測っていて、遅くなった瞬間に気づく直前に入れた変更が犯人だと分かる

後者が圧倒的に安いです。 変更の直後に分かれば、疑う範囲が1回分の変更に絞れます。 ②で入れた「全リクエストの処理時間をログに出す」は、そのための土台です。あとは、それを集めて眺める仕組みを足すだけです。 その話が監視の回です。 そして、遅いを通り越して落ちたときが障害対応の回になります。

つまずいたところ

症状原因
ビルドしたのに Network の数字が変わらないDisable cache を入れていない。 古いファイルがキャッシュから返っている
npm run preview にブラウザから繋がらない--host 0.0.0.0 を付けていない、または ufw で 4173 を開けていない
Lighthouse のスコアが毎回違う正常。 数点はぶれる。シークレットウィンドウで2〜3回走らせて真ん中を取る
Lighthouse が「未使用のJSが多い」と言うnpm run dev を測っている可能性が高い。 ビルドしてから測る
convert: command not foundImageMagick の版違い。magick で試す
identify は動くが cwebp が無いwebp パッケージを入れていない
画像を差し替えたのに反映されないnpm run build をやり直していない。 dist/ は古いまま
EXPLAIN が type: ALL のまま索引が使えない書き方(LIKE '%x%'、列に関数)。possible_keys が NULL なら候補にすら入っていない
possible_keys に出るのに key が NULLMySQLが「使わないほうが速い」と判断した。 対象行が多すぎるとこうなる。ANALYZE TABLE appdb.tasks; で統計を取り直すと変わることがある
migrate:latest が何もせずに終わるすでに適用済み。 migrate:status で確認する
索引を張ったのに INSERT が遅くなった正常。 索引の代金。張りすぎていないか見直す
SQL 101本 が出ないknex.on("query", ...) を、knex を作る前に書いている
queryCount の数字がおかしい同時に叩いている。 1本ずつ測る
byId.get(...) が undefined で落ちる参照先のユーザーが消えている。 ?. で受けるか、先に存在を確かめる
スロークエリログが空のままlong_query_time より速い。一時的に 0.05 まで下げて確かめる
tail: cannot open でログが読めないsudo を付けていない。 MySQLのログは一般ユーザーから読めない

後片づけ

ダミーの20万件を消します。

bash
$ sudo mysql -e "SELECT COUNT(*) FROM appdb.tasks WHERE title LIKE 'ダミー%';"
$ sudo mysql -e "DELETE FROM appdb.tasks WHERE title LIKE 'ダミー%';"
$ sudo mysql -e "SELECT COUNT(*) FROM appdb.tasks;"

必ず、先に同じ WHERE で SELECT COUNT(*) して件数を見てから消してください。 MySQLの回の一番大事な話です。

索引を戻すとき。

bash
$ cd ~/server
$ node --env-file=.env.migrate node_modules/knex/bin/cli.js migrate:rollback

索引は残しておいても構いません。 邪魔にはなりません。戻し方を知っているかどうかが大事です。

スロークエリログを止めます。

bash
$ sudo mysql -e "SET GLOBAL slow_query_log = 'OFF';"

N+1の実験用エンドポイント(/api/tasks/withuser)と /api/report は、消して構いません。

残すもの。

  • app.use の処理時間ログ …… 入れっぱなしにしてください。これが一番役に立ちます
  • 画像を小さくする手順 …… photo.jpg(元の大きいほう)は消してよいですが、小さくした画像は残す

まとめ

  • 推測でチューニングしない。 測る → 一番遅い1箇所だけ直す → もう一度測る
  • 体感の遅さは1箇所で決まる。 全体の6%を半分にしても、体感は変わらない
  • 平均を見ない。 見るのは p50 と p95。遅いと言ってくる人は p95 を踏んでいる
  • フロントとバックで道具が違う。 ブラウザは Network / Lighthouse、サーバーは自分で仕込むログと EXPLAIN
  • 切り分けの起点は TTFB。 長ければサーバー側、短いのに遅ければブラウザ側
  • 開発サーバーの数字は当てにならない。 必ず npm run build した dist/ を配って測る
  • Disable cache と回線の絞り込みを入れずに測らない。 手元は速すぎる
  • 一番重いのは、たいてい画像とフォント。 写真1枚 4MB は、JS を10KB削る努力の400倍重い
  • Lighthouse は点数ではなく Opportunities の ms を読む。 スコア100は目的にならない
  • サーバーは、時間の使い道を分解する。 受け取り / DB / 外部API / 返す。console.log で十分
  • EXPLAIN の最初に見る3つは type と key と rows。 ALL + NULL + 巨大な rows は索引の話
  • 索引の価値は「いま速い」ではなく「増えても遅くならない」。 フルスキャンは件数に比例する
  • 索引は無料ではない。 書き込みが遅くなり、容量を食う。張ったら EXPLAIN で使われていることを確かめる
  • LIKE '%x%' と、列に関数を掛けた条件には索引が効かない
  • rows が大きくても、結果も全行が対象なら索引では直らない。 そこがキャッシュの出番
  • N+1は、1本ずつ見ている限り絶対に見つからない。 SQLの本数を数える
  • 見つけ方は形で覚える。「ループの中の await でDBや外部APIを呼んでいないか」
  • キャッシュは最後。 回数を減らす → 1回を速くする → 返す量を減らす → それでも駄目なら
  • 目標値を決める。 決めていない改善は終わらない。測って許容範囲なら直さない
  • 「速くする」より「遅くならないよう見張る」。 処理時間のログを残すことが、その第一歩

参考リンク


次に読む

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

記事
← 前の記事まだマイクロサービスにしない — モノリスと12 Factor
→ 次の記事L4とL7の違いは中身を見るか — OSI参照モデル

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

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

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

Frontend/Backend›Performance / Scaling Databases
  • Web Performance(測ってから直す)
  • Indexes and how they work
  • N+1 問題
  • Profiling / Web Vitals
  • Caching は最後の手段

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

「速くする」より「遅くならないよう見張る」に繋げるため、監視の回と対にして読んでください。

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

コメント

コメントする

目次