「なんか遅い」を心当たりで直すと当たりません。フロントとデータベースを別々に測り、EXPLAINで裏を取る順番を決めます。
前回: まだマイクロサービスにしない — モノリスと12 Factor 作業場所はVMの中(Ubuntu)です。ここまでで作った
~/server(API)と~/react-demo(フロント)を、そのまま使います。
「なんか遅いんですけど」と言われたとき、一番やってはいけないのがこれです。
「たぶんデータベースかな……」と思って、心当たりのあるSQLを書き直す。
当たることもあります。 ただ、当たったかどうかも分かりません。直す前の数字が無いからです。
この回でやるのは、その順番を変えることです。
測る → 一番遅いところを1つだけ直す → もう一度測る。
Redis の回で「入れる前に必ず測る」をやりました。あれと同じ型を、今度はフロントとバックの両方に広げます。 そして、Redis の回で扱えなかったほう —— 索引を張れば直る遅さ —— を、今回の山場にします。
対象レベル: 中級 / 区分: 必修
この記事でわかること
- 体感の遅さは、たいてい1箇所で決まること。全部を少しずつ速くしても体感は変わらないこと
- フロントとバックでは、測る道具がまったく違うこと。同じ「遅い」でも見る場所が別だということ
- 開発サーバーで測った数字は当てにならないこと。ビルド済みの
dist/を配って測らないと意味がないこと EXPLAINを読めば「全部読んでいる」が目で見えること。索引はコピペで張るものではないこと- キャッシュは最後の手段で、先にやると遅い原因が隠れたまま残ること
- 測って許容範囲なら直さない、という判断があること
この記事でやること
- フロントを測る。
npm run buildしたdist/を配って、開発者ツールの Network と Lighthouse で見る - バックを測る。 リクエスト1本の処理時間をログに出し、どこで時間を使っているか分解する
- わざと遅いクエリを作り、
EXPLAINで全件走査を確認し、索引を張って直して測り直す - N+1問題を実際に作って、問い合わせが101回飛んでいることをログで見て、1回に直す
- 直さない判断をする。 目標値を決めて、それを下回っているものは触らない
先に知る言葉
この記事で初めて出てくる言葉です。 基本的な言葉は用語集にもまとめてあります。
| 言葉 | 意味 |
|---|---|
| ボトルネック | 全体の速さを決めてしまっている1箇所。 瓶の首。ここ以外を速くしても全体は変わらない |
| プロファイリング | どこで時間を使っているかを実際に測って分解すること。推測の反対語 |
| レイテンシ / スループット | レイテンシ=1本にかかる時間、スループット=1秒に何本さばけるか。別のもので、片方だけ良いことがある |
| TTFB | Time 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 -w | TTFB |
| サーバー側(アプリの処理) | 自分で仕込むログ | 処理時間の内訳 |
| データベース | EXPLAIN、スロークエリログ | 読んだ行数、実行時間 |
切り分けの起点は1つだけです。
開発者ツールの Network で、そのAPIの TTFB を見る。 TTFB が長ければサーバー側。短いのに画面が遅ければブラウザ側。
開発者ツールの回で「ページが重いときは Network の Time 列」と書きました。あれが、この記事の入口です。
① フロントを測る
開発サーバーの数字は、当てにならない
先にここを潰します。 これを知らないと、以降の測定が全部無駄になります。
この状態で Network タブを開くと、ファイルが何十本も並びます。 そして遅く見えます。でも、それは本番と何の関係もありません。
npm run dev | npm run build した dist/ | |
|---|---|---|
| ファイルの配り方 | 1ファイルずつ、そのまま | まとめて1〜数本(バンドル) |
| 中身 | 人が読める形のまま | minify 済み(改行も変数名も削られている) |
| 余計なもの | HMR のクライアントが乗っている | 無い |
| 圧縮 | 基本かからない | nginx が gzip で送る |
ビルドツールの回でやった話が、そのまま効いてきます。
開発サーバーは「速く書き換えるため」の道具で、「速く配るため」の道具ではありません。 測るときは、必ず
npm run buildしてから測ります。
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枚置いてください。 加工しないでください。それがまさに事故の形だからです。
3〜5MB あるはずです。 src/App.jsx のどこかに、そのまま貼ります。
<img src="/photo.jpg" alt="テスト用の写真" />
もう一度 Network を見てください。 JS と CSS が合わせて数十KBなのに対し、写真1枚が数MBです。
dist/assets/index-xxxx.jsを 10KB 削る努力と、写真1枚を 4MB → 200KB にする作業は、効果が20倍以上違います。 にもかかわらず、前者のほうが「技術的で偉い作業」に見えます。 ここが罠です。
直します。 画像を扱う道具を入れます。
photo.jpg JPEG 4032x3024 4032x3024+0+0 8-bit sRGB 4.21MB 0.000u 0:00.000
4032x3024。 表示しているのは、どう大きくても画面幅 1200px 程度です。4032px は、そのまま捨てられています。
-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 を、もう少し細かくします。
別のターミナルで、ログインしてから測ります。
接続:0.000138s 最初の1バイト:0.041902s 合計:0.042051s
| 数字 | 意味 |
|---|---|
time_connect | 繋がるまで。 ここが長い=ネットワークの問題 |
time_starttransfer | TTFB。 ここが長い=サーバーが考えている |
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を引いている |
| DB | SQLを投げて待つ | 索引が無い、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 自身に吐かせます。
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 して、別のターミナルで流しておきます。
この状態でAPIを叩くと、0.2秒を超えたSQLだけが流れてきます。
SET GLOBALはMySQLを再起動すると消えます。 練習ではそのほうが安全です。設定ファイルに書くのは、本当に常時必要になってからで構いません。 本番でlong_query_timeを 0 にしないでください。 全部のクエリが書かれてディスクが埋まります。
③ 索引を張れば直る遅さ
ここがこの記事の中心です。
Redis の回では、索引を張っても直らない遅さを扱いました。20万行すべてが user_id = 1 だったので、読み飛ばす行が1行も無かったからです。
今回は逆です。索引で直るほうをやります。 そして、その2つを見分けられるようにします。
遅い状態を、もう一度作る
Redis の回の後片づけでダミーを消しているので、入れ直します。
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つだけです。
| 列 | この結果 | 意味 |
|---|---|---|
type | ALL | 最悪の値。 「全部読む」という宣言 |
key | NULL | 索引を1つも使っていない |
rows | 199243 | 読むつもりの行数の見積もり。 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 を打ちません。
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");
});
};
20万行への索引作成は、数秒かかります。 練習では一瞬ですが、本番の大きなテーブルでは、その間テーブルが重くなります。 「索引を張るのは無料」ではありません。
もう一度 EXPLAIN
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つとも変わりました。
| 前 | 後 | |
|---|---|---|
type | ALL | ref |
key | NULL | idx_tasks_title |
rows | 199243 | 1 |
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 = 0 | 2列まとめた索引(複合索引)が要る。片方ずつ張っても片方しか使われないことが多い |
LIKE '%キーワード%'は、索引では速くなりません。 全文検索の仕組み(MySQLならFULLTEXT)か、専用の検索エンジンの話になります。そこまで来たら、それは別の道具の出番です。 確かめ方は1つだけです。EXPLAINを打つ。 「効くはず」で終わらせないでください。
Redis の回と、どう見分けるか
同じ「遅い」でも、直し方が違います。 ここが今回いちばん持ち帰ってほしい表です。
| 症状 | EXPLAIN の見え方 | 直し方 |
|---|---|---|
| 少数の行を探すのに全件読んでいる | type: ALL、rows が大きい、結果は数行 | 索引(今回) |
| 本当に大量の行を集計している | rows が大きい、結果も全行が対象 | キャッシュ(Redis の回) |
| 同じ問い合わせが何度も来る | 1本は速いが、回数が多い | キャッシュ、または呼ぶのをやめる |
| 1本1本は速いのに合計が遅い | どれも rows: 1 | N+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本ずつ手で叩いて測るので、これで足ります。 本番でこの形にはしません。
サーバー側のログを見てください。
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を潰す) | ④ |
| 3 | 1回を速くする(索引) | ③ |
| 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 found | ImageMagick の版違い。magick で試す |
identify は動くが cwebp が無い | webp パッケージを入れていない |
| 画像を差し替えたのに反映されない | npm run build をやり直していない。 dist/ は古いまま |
EXPLAIN が type: ALL のまま | 索引が使えない書き方(LIKE '%x%'、列に関数)。possible_keys が NULL なら候補にすら入っていない |
possible_keys に出るのに key が NULL | MySQLが「使わないほうが速い」と判断した。 対象行が多すぎるとこうなる。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万件を消します。
必ず、先に同じ
WHEREでSELECT COUNT(*)して件数を見てから消してください。 MySQLの回の一番大事な話です。
索引を戻すとき。
索引は残しておいても構いません。 邪魔にはなりません。戻し方を知っているかどうかが大事です。
スロークエリログを止めます。
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回を速くする → 返す量を減らす → それでも駄目なら
- 目標値を決める。 決めていない改善は終わらない。測って許容範囲なら直さない
- 「速くする」より「遅くならないよう見張る」。 処理時間のログを残すことが、その第一歩
参考リンク
- roadmap.sh — System Design
- roadmap.sh — Backend
- MySQL — EXPLAIN Statement
- MySQL — How MySQL Uses Indexes
- MySQL — The Slow Query Log
- Lighthouse の概要(Chrome for Developers)
- Web Vitals(web.dev)
- MDN — Web Performance
- MDN — img の loading 属性
- curl — manpage(
-wの書式) - Knex — Migrations / Events
次に読む
この記事は 【第8段階】深掘り の 7 / 30 本目です。
上から順に読めば積み上がるように並べています。 飛ばしても構いませんが、詰まったら前の回に戻ってください。
全体の順路は はじめに にあります。

コメント