システム設計の記事を10本読んでも、自分のサーバーのどこが先に詰まるかは、1つも分かりません。
前回: サービスディスカバリと名前解決 — 相手のIPを書いたら翌日壊れた
これはシステム設計深掘りの「到達作品」の回です。 新しい知識は、ほとんど出てきません。これまでこのコースで見てきたもの——台数を増やしたら遅くなった(レイテンシとスループット) / キャッシュを入れたのに速くならない / 遅い原因は推測では当たらない(アンチパターン)——を、1つの流れに束ねる回です。読むだけだった知識を、「自分の手で数字を出せる成果」に変えます。
この記事のコマンドは、VMの中(Ubuntu Server)で打ちます。 Windows 本体では打ちません。MySQL 8.0 以降と Node.js が動いていれば、それ以外の準備は要りません。練習用のデータベースとアプリは、この記事の中で作って、最後に全部消します。既存のデータベースやアプリには一切触りません。 500,000 行を入れるので、VMのディスクに 500MB 程度の空きがあることだけ、先に確かめてください。
四角と矢印の図をいくら眺めても、「いま自分のAPIは1秒に何件さばけるのか」を知らないままだからです。ロードバランサを置く理由も、キャッシュを入れる理由も、自分の数字を持っていないと、ただの受け売りになります。
そして、この分野で一番多い失敗が、これです。
遅いと聞いて、当たりを付けて、そこを直した。速くならなかった。
なぜ速くならないのか。直した場所が、詰まっていた場所ではなかったからです。
速くする前にやることは、「速くする方法を選ぶこと」ではありません。 「どこがどれだけ遅いかを、数字にすること」です。
この回では、それを最後まで一人でやります。わざと遅いアプリを立て、負荷をかけて p95 が悪化する点を見つけ、ボトルネックを1つだけ特定して、潰して、また測って、Before/After を1枚の表にする。 新しいクラウドサービスは1つも使いません。使うのは、これまでのコースで手に入れたものと、ab という小さな負荷試験ツール1つだけです。
このループ——「測る → 1つ特定 → 潰す → また測る」——を体で覚えたら、システム設計は「読むもの」から「やれるもの」に変わります。 それがこの到達作品のゴールです。
対象レベル: 中級〜上級 / 区分: 発展
めがける作品
このコースを終えたら、これが言い切れるようになっている。 ——「索引を張ると速くなる」ではなく、「このAPIは、負荷をかけたら p95 が 2.1 秒だった。ボトルネックは MySQL の全表走査だと top とプロセス一覧で確かめた。索引を1本張ったら p95 が 95 ミリ秒になった」。
ここで作るのは、派手なアプリではありません。わざと遅くしたAPIと、Before/After の数字が並んだ表1枚です。地味に見えますが、システム設計深掘りコースで学んだことが、ここに全部乗ります。
素材にするのは、どのサービスにもある「あるある」な遅いAPIです。
- 注文を絞り込んで新着順に出す——
GET /orders?customer=4242 - 中身は
SELECT ... FROM orders WHERE customer_id = ? ORDER BY created_at DESC LIMIT 20 - テーブルは 50万行。わざと
customer_idに索引を張っていないので、1リクエストごとに50万行を全部見て、並べ替えます
1人で開くと、速く見えます。 ブラウザでポチッと開けば 0.1 秒くらいで返ってくるからです。ところが、50人が同時に叩いた瞬間、p95 が2秒を超えて崩れます。 その「崩れる点」を数字で捕まえて、原因を1つに絞って、直す——それがこの記事です。
完成すると、こう言えます。
同じ負荷(-n 2000 -c 50)で、同じAPIがこう変わった:
スループット p50 p95 p99
索引なし 38 req/s 1250 ms 2100 ms 2600 ms
索引あり 1100 req/s 38 ms 95 ms 160 ms
↑ 約29倍 ↑ 22分の1
ボトルネックは MySQL の全表走査。索引を1本張って解消。
→ 次に詰まるのは Node.js の1プロセス(1コア)。ここで止める。
「速くなった気がする」ではなく、この表を自分の手で埋めること。 それがこの記事のゴールです。そして、この作業の順番——「先に測る → 1つ特定 → 潰す → また測る」——が、この先ずっと使う型になります。
この記事でわかること
- 「速くする前に必ず測る」の意味。測らずに直すと、効いたのか偶然かが永久に分からないこと。当たりを付けて直すのは、当たった時だけ正しく見える危ない博打だということ
- 平均は嘘をつくこと。「平均 200ms」でも、100人に1人は2秒待っている。ユーザーが感じるのは平均ではなく、自分に当たった1回。だから p95・p99 を見る
- ボトルネックは1つずつしか潰せないこと。CPU・メモリ・ディスクI/O・DBのうち、一番詰まっている1つを直す。他を直しても、全体は1ミリも速くならないこと
- ボトルネックは動くこと。1つ潰すと、次に詰まる場所が別に現れる。だから「全部速くする」は無く、要件を満たしたら止めるのが正解だということ
- 負荷をかけないと、遅さは見えないこと。1人で開いて速いのは、行列がまだ無いから。詰まりは同時接続で初めて現れる
EXPLAINのtype=ALL(全表走査)とtopの CPU が、原因の「証拠」になること。感覚ではなく証拠でボトルネックを名指しできること
この記事でやること
- わざと遅いAPIを立てる——MySQL に 50万行を作り、索引の無い列で絞る Node.js のAPIを1つ動かす
- 負荷試験ツール
abを入れて、いまの数字を出す——スループットと p50・p95・p99 を記録する - ボトルネックを1つ特定する——
top/vmstat/ MySQL のプロセス一覧・スロークエリで、CPU・DBのどこが詰まっているかを切り分ける - ボトルネックを1つだけ潰す——
CREATE INDEXを1本張る(他は何も変えない) - 同じ負荷で測り直し、Before/After を1枚の表にする——スループット・p95・p99 を並べる
- 次のボトルネックがどこへ移ったかを確かめる——
topを見て、止めどきを要件で決める - 完成の判定(チェックリスト)を自分で通し、練習用の一式を消す
先に知る言葉
この記事で軸になる言葉です。 基本的な言葉は用語集にもまとめてあります。
| 言葉 | 意味 |
|---|---|
| スループット | 1秒に何件さばけるか(req/s)。「速さ」のうち、量のほう |
| レイテンシ | 1件が返るまで何ミリ秒か。「速さ」のうち、待ち時間のほう |
| パーセンタイル(p95 / p99) | 遅いほうから見た順位。p95 = 95%の人はこれより速い=100人中5人はこれより遅い。p99 は100人に1人。平均より、こちらが本当の体感 |
| 負荷試験(ベンチマーク) | わざと大量のリクエストを送って、限界の数字を測ること |
ab(Apache Bench) | 定番の負荷試験ツール。apache2-utils に入っている。ab は素のUbuntuに入っていないので、apt で入れる |
同時接続数(-c) | 一度に何人が同時に叩いているか。行列の人数。詰まりは、ここを増やすと現れる |
| 全表走査(フルスキャン) | 索引が無いとき、DBがテーブルの全行を上から順に見ること。50万行なら毎回50万行読む |
| ボトルネック | 全体の速さを決めている、一番細いところ。瓶の首。ここ以外を直しても速くならない |
| ウォームアップ | 測る前に軽く空回しして、キャッシュを温めておくこと。1発目は遅く出るので、それを混ぜない |
① まず測る。推測で直さない
この記事で一番大事なのは、コードでも索引でもなく、順番です。
やってはいけないのは、これです。
「たぶん DB が遅いんだろう」→ 索引を張る →「速くなった気がする」→ 終わり
なぜ危ないか。「気がする」を根拠にすると、効かなかった時に気づけないからです。索引を張った日にたまたま負荷が軽ければ、索引が効いたのか、暇だっただけなのか、区別が付きません。 次の日にまた遅くなって、また別の場所を当てずっぽうで触る——これが、直らないシステムの回り方です。
よくある回り道は、こういう形で起きます。
「重い」と言われた → CPU が高い気がしたので、サーバーのスペックを上げた(お金がかかった)→ 少しマシになった気がした → 1週間後にまた重い → 今度はキャッシュを入れた(コードが複雑になった)→ たまに古い値が返るバグが増えた → それでも根本は重いまま……
全部、「測っていない」から起きています。 もし最初に測っていれば、「詰まっているのは CPU でも memory でもなく、索引の無いクエリ1本」と分かって、スペックも上げず、キャッシュも入れず、索引1本で終わっていたはずです。測らずに動くと、時間もお金も、そして「壊れやすさ」まで払うことになります。これがこの記事で一番避けたい失敗です。
正しい順番は、たった4歩です。
- 測る——いまの数字(スループット・p95・p99)を紙に書く
- 1つ特定する——どこが詰まっているか、証拠を1つ挙げる
- 潰す——その1つだけを直す。他は触らない
- また測る——同じ負荷で測り直し、数字が動いたか見る
③と④の間に何本も直してはいけません。 索引も張ってキャッシュも入れてプロセスも増やして、それで速くなっても、どれが効いたのか分からないからです。1回の改善で、変えるのは1つ。これが鉄則です。
図にすると、こういう円を回すだけです。
┌─────────────────────────────────────────────┐
│ │
▼ │
① 測る ──▶ ② 1つ特定 ──▶ ③ その1つだけ潰す ──▶ ④ また測る
(数字を書く)(証拠を挙げる)(他は触らない) (数字が動いたか)
│ │
│ 要件を満たした? ── はい ──▶ 止める(完成) │
└── いいえ ────────────────────────────────────┘
(次のボトルネックへ、また①から)
止まる条件は「速くなった」ではなく「要件を満たした」です。 ここを混同すると、いつまでも終わらない改善に沈みます。速さには上限がなく、要件には上限があります。この円のどこで降りるかを決めるのが、この記事の裏テーマです。
この「測ってから直す」は、速くする前に必ず測る — パフォーマンス改善とEXPLAIN で SQL 1本に対してやったことと、同じ型です。今回はそれを、API全体・負荷ありでやります。そして、遅い原因は推測では当たらない — システム設計深掘り で「当たらない」と言い切った理由を、今日は自分の手で確かめます。
合言葉は1つ。「測ってから直す」。 これができれば、この記事は半分終わっています。
測る道具を、先に3つそろえる
「測る」と言っても、道具がないと何も見えません。この記事で使う道具は、たった3種類です。何を見る道具か、先に頭に入れておきます。
| 道具 | 何を測るか | いつ使うか |
|---|---|---|
ab | API全体の速さ(スループット・p95・p99) | ③・⑤——外から負荷をかけて測る |
top / vmstat | どのプロセスが、CPU・メモリ・I/Oを食っているか | ④——負荷の最中に、詰まりの場所を見る |
EXPLAIN / スロークエリlog | DBが、どのクエリで、どう詰まっているか | ④——DBの中の犯人を特定する |
この3つは、役割が重なりません。 ab は「遅い」を教えますが「なぜ」は教えません。top は「どこが」を教えますが「どのクエリ」までは教えません。EXPLAIN が最後の1本を名指しします。外から内へ、順にズームインしていく——それが、この記事の④でやることです。
この記事が束ねる、これまでの深掘り
到達作品なので、新しい知識はほとんど出しません。 その代わり、これまでバラバラに読んできた深掘りが、この1本の中でそれぞれの役割を持って現れます。今日やることが、どの回の何を使っているかを、先に地図にしておきます。
| この記事の手順 | 束ねる深掘り | そこで学んだこと |
|---|---|---|
| ③ p95・p99 で判定する | 台数を増やしたら遅くなった | スループットには天井があり、超えるとレイテンシだけ伸びる |
| ④ 推測せず証拠で特定する | 遅い原因は推測では当たらない | 当てずっぽうは当たらない。測ってから動く |
| ⑤ 直し方の選択肢 | キャッシュを入れたのに速くならない | DBに聞く回数を減らす、という同じ発想 |
| ⑥ 次のボトルネックへ | ボトルネックは動く(負荷分散) | 1つ潰すと次が現れる。1プロセスは1コア |
一本一本は「読んで分かった」で終わっていました。 それを、自分のVMで数字を出す1つの流れに通すのが、この到達作品です。読んだ知識は、測って初めて自分のものになります。
② わざと遅いAPIを立てる
まず、詰まる題材を用意します。 ここでのコツは、わざと1箇所だけ遅くすることです。全部が均等に遅いと、ボトルネックが1つに定まらず、練習になりません。索引の無いクエリを、意図的に仕込みます。
「わざと遅くする」には、定番が3つあります。どれも、実際のアプリで一番よく踏む地雷です。
| 仕込み方 | どう遅いか | 現実にどこで出るか |
|---|---|---|
| 索引の無いクエリ | 1回ごとにテーブル全行を走査する | 一覧・検索・プロフィール。今回はこれを使う |
| 同期I/O | 応答の途中で、ファイル読みや外部APIを待って固まる | 画像処理、他サービス呼び出し |
| N+1クエリ | 一覧20件を出すのに、20回+1回、DBを叩く | 「一覧に付随情報を添える」画面 |
今回は「索引の無いクエリ」を選びます。 理由は、直し方(索引を1本)が一番はっきりしていて、Before/After が桁で動くから、練習の題材として一番きれいだからです。同期I/O や N+1 でも、この記事の「測る → 特定 → 潰す → また測る」はまったく同じ手順で通用します。
VM 直でやります(Docker でもできます)。 この記事は、第5段階で入れた VMの MySQL と Node.js を直接使います。 Docker を通したほうが後片づけは楽(コンテナごと捨てられる)ですが、負荷試験では「余計な層を挟まない」ほうが、数字が読みやすいという利点があります。Docker のネットワークやボリュームを挟むと、遅さがそのせいなのか本体なのか、切り分けが1つ増えます。すでにDockerに慣れているなら
mysqlとnodeのコンテナで組んでも構いません——測る手順はまったく同じです。ここでは、切り分けを単純にするため、VM に直接置きます。
練習用のデータベースを作る
MySQL に入って、この記事専用のデータベースとユーザーを作ります。既存のデータベースには触りません。 新しく bench_cap を作るだけです。
MySQL のプロンプトで、次を打ちます。
CREATE DATABASE bench_cap;
CREATE USER 'bench'@'localhost' IDENTIFIED BY 'benchpass';
GRANT ALL PRIVILEGES ON bench_cap.* TO 'bench'@'localhost';
FLUSH PRIVILEGES;
確認します。bench_cap が一覧に出れば成功です。
SHOW DATABASES;
50万行のテーブルを作る
bench_cap に切り替えて、注文テーブルを作ります。この時点では、索引を1つも張りません(customer_id に索引が無いのが、この記事の「わざと遅い」の正体です)。
USE bench_cap;
CREATE TABLE orders (
id INT PRIMARY KEY AUTO_INCREMENT,
customer_id INT NOT NULL,
amount INT NOT NULL,
created_at DATETIME NOT NULL
);
50万行を、手で入れず、SQLで生成します。 WITH RECURSIVE で 1〜50万の連番を作り、そのぶんだけ乱数の行を入れます。再帰の深さの上限(既定 1000)を先に上げておかないと、途中で止まります。
SET SESSION cte_max_recursion_depth = 1000000;
INSERT INTO orders (customer_id, amount, created_at)
WITH RECURSIVE seq AS (
SELECT 1 AS n
UNION ALL
SELECT n + 1 FROM seq WHERE n < 500000
)
SELECT
FLOOR(RAND() * 10000) + 1,
FLOOR(RAND() * 100000) + 1,
NOW() - INTERVAL FLOOR(RAND() * 3650) DAY
FROM seq;
customer_id は 1〜10000 の乱数なので、特定の顧客の注文は50件くらいになります。50万行の中から、その50件を毎回探すことになります。
なぜ50万行なのか。 少なすぎると、問題が見えません。 数百行なら、索引が無くても一瞬で終わり、負荷をかけても詰まらないので、「索引の効果」がグラフに出ません。逆に多すぎると、生成と後片づけに時間がかかります。 50万行は、索引の有無で p95 が桁で動くのに、生成は数十秒・容量は数百MBで済む、ちょうどいい大きさです。自分のVMが非力なら10万行でも同じ傾向は見えます(差は小さくなります)。
件数を確認します。500000 が返れば成功です。
SELECT COUNT(*) FROM orders;
MySQL を出ます。
EXIT;
索引が無いと、1本のクエリがどれだけ遅いか
負荷をかける前に、クエリ1本の遅さを見ておきます。ここが後で効いてきます。もう一度 MySQL に入って、bench_cap で EXPLAIN を打ちます。
EXPLAIN
SELECT id, amount, created_at
FROM orders
WHERE customer_id = 4242
ORDER BY created_at DESC
LIMIT 20;
こう返ってきます。
+----+-------------+--------+------+---------------+------+---------+------+--------+----------------------------+
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+----+-------------+--------+------+---------------+------+---------+------+--------+----------------------------+
| 1 | SIMPLE | orders | ALL | NULL | NULL | NULL | NULL | 498210 | Using where; Using filesort|
+----+-------------+--------+------+---------------+------+---------+------+--------+----------------------------+
見るのは2つだけです。
type = ALL——全表走査。索引を1つも使わず、50万行を上から全部見ているExtraのUsing filesort——さらに、その全行を並べ替えている(ORDER BY created_at)
これが「わざと遅い」の正体です。 1リクエストごとに、50万行を読んで、並べ替えて、上位20件を返す。1人なら、それでも 0.1〜0.3 秒で返ります。 問題は、これが50人分同時に走った時に起きます。MySQL を出ます。
EXIT;
APIを1つ立てる
このクエリを叩く、小さな Node.js のAPIを書きます。作業用のフォルダを作って入ります。
app.js を作ります(nano app.js などで)。30行ほどです。/orders?customer=番号 に来たら、さっきの遅いクエリを流すだけです。
const http = require("http");
const mysql = require("mysql2/promise");
const pool = mysql.createPool({
host: "127.0.0.1",
user: "bench",
password: "benchpass",
database: "bench_cap",
connectionLimit: 10,
});
const server = http.createServer(async (req, res) => {
const url = new URL(req.url, "http://localhost");
if (url.pathname === "/orders") {
const customer = Number(url.searchParams.get("customer")) || 1;
const [rows] = await pool.query(
"SELECT id, amount, created_at FROM orders WHERE customer_id = ? ORDER BY created_at DESC LIMIT 20",
[customer]
);
res.setHeader("content-type", "application/json");
res.end(JSON.stringify(rows));
return;
}
res.statusCode = 404;
res.end("not found");
});
server.listen(3000, () => console.log("listening on http://127.0.0.1:3000"));
起動します。
listening on http://127.0.0.1:3000 と出れば動いています。このターミナルはAPIを動かしっぱなしにするので、負荷試験は別のターミナル(もう1枚 SSH でVMに入る)で打ちます。
別ターミナルから、1回だけ叩いて、中身が返ることを確認します。
JSON の配列が返れば成功です。1回だと、たぶん一瞬で返ります。 ここが罠です。1人で速いことは、何の保証にもなりません。 次で、50人にします。
③ 負荷をかけて、数字を出す
ここからが本番です。 1人では見えなかった詰まりを、同時接続を増やして引きずり出します。
負荷試験ツールを入れる
ab(Apache Bench)を使います。ab は素のUbuntuには入っていません。 apache2-utils パッケージに入っているので、apt で入れます。
入ったか確認します。バージョンが出れば成功です。
heyでもできます。abの代わりにheyという新しめのツールもよく使われます(p95・p99 をそのまま表示してくれます)。ただしheyはaptの標準リポジトリには無く、配布バイナリを別に入れる必要があるので、この記事では、どのVMでもapt一発で入るabを使います。 考え方はまったく同じです。
-n と -c はどう決めるか
2つのオプションの意味を、先に押さえます。
-c(同時接続数)=行列に並んでいる人数。 これが「どれくらいの混み具合を再現するか」を決めます。主役はこちらです-n(総リクエスト数)=合計で何回叩くか。 これは「どれくらいの長さ測るか」を決めます。短すぎると数字がブレます
-n は -c より十分大きく取ります。 目安は、-c の20〜40倍。-c 50 なら -n 2000 くらい。理由は、リクエストが数十件では、たまたま速い・遅いのブレを拾ってしまうからです。ある程度の数を流して、ならした値を見ます。
逆に、-n を大きくしすぎると、測定に何分もかかり、同じVMだと top を見る余裕も無くなります。 「1〜2分で終わる範囲」で、-n を選びます。今回の -n 2000 -c 50 は、その塩梅です。
ウォームアップしてから測る
いきなり本番を測ってはいけません。 1発目は、MySQL のバッファプールが冷えていて、遅く出ます。軽く空回しして温めます。
この数字はメモしません。ウォームアップです。
本番の負荷をかける
2000リクエストを、50人同時で送ります。-n が総リクエスト数、-c が同時接続数です。
[スクリーンショット: 01_before_ab.png] 索引を張る前の ab の結果を撮ってください。Requests per second と、下のほうの 95% の行が写るようにしてください。
こういう結果が返ります(数字は環境で違います)。
Concurrency Level: 50
Time taken for tests: 52.631 seconds
Complete requests: 2000
Failed requests: 0
Requests per second: 38.00 [#/sec] (mean)
Time per request: 1315.775 [ms] (mean)
Percentage of the requests served within a certain time (ms)
50% 1250
75% 1680
90% 1950
95% 2100
99% 2600
100% 3400 (longest request)
この結果から、記録するのはこの4つです。
| 指標 | どこを見るか | 値 |
|---|---|---|
| スループット | Requests per second | 38 req/s |
| p50(中央値) | 50% の行 | 1250 ms |
| p95 | 95% の行 | 2100 ms |
| p99 | 99% の行 | 2600 ms |
ab の出力には、他にも行があります。最初に意味を知っておくと、結果が読めます。
Complete requests——最後まで返ってきた数。-nと一致していれば、全部さばけたFailed requests——失敗した数。0 が理想。ただし後述のとおり「長さの差」で数えられることもあるRequests per second——スループット。大きいほど良いTime per request ... (mean)——平均レイテンシ。参考程度。判断は下の95%を使うPercentage of ... within a certain time——ここが本命。50%・95%・99%がパーセンタイル(longest request)——一番遅かった1件。p100。外れ値なので、これ単体では判断しない
同時接続を増やして、「崩れる点」を探す
1回測っただけでは、まだ半分です。 同時接続数(-c)を少しずつ増やして、どこで p95 が崩れるかを見つけます。 これが「限界を数字にする」ということです。1人(-c 1)なら速いのに、何人からダメになるのか——その境目を捕まえます。
-n は総数を -c の20倍くらいに合わせつつ、-c だけを変えて何回か回します。
各回の Requests per second と 95% の行だけ拾って、並べます。
同時接続 -c | スループット | p95 | 様子 |
|---|---|---|---|
| 1 | 6 req/s | 180 ms | 1人なら普通に返る |
| 10 | 33 req/s | 480 ms | まだ耐えている |
| 25 | 37 req/s | 1100 ms | p95 が跳ね始めた |
| 50 | 38 req/s | 2100 ms | スループットは頭打ち、待ち時間だけ倍増 |
| 100 | 38 req/s | 4300 ms | 増やしても速くならず、行列が伸びるだけ |
ここに、この分野の核心が全部出ています。
-c 1から-c 10へは、スループットが素直に伸びた(6 → 33 req/s)。まだ余裕がある区間-c 25あたりで、p95 が急に跳ねた(480 → 1100 ms)。ここが「崩れる点」。これ以上人を入れても、スループットは 38 req/s で頭打ち-c 50・-c 100は、スループットが1ミリも増えず、p95・p99 だけが倍々で伸びる。これは「行列に人を足しているだけ」の状態です
台数を増やしたら遅くなった — システム設計深掘り で見た「スループットには天井があり、そこを超えるとレイテンシだけが伸びる」を、自分の数字で再現できました。この天井(38 req/s)が、いま自分のシステムの限界です。 これを上げるのが、この先の仕事になります。
ab が測っているものを、誤解しない
数字を信じる前に、ab が何をしているかを1つだけ押さえます。-c 50 は「50人の仮想ユーザーが、1件返ってきたら即・次を投げる」という動き方です。行列の長さが常に50に保たれる——これを クローズドループと言います。
ここに、初心者が引っかかる罠があります。
abの p95 は「サーバーが遅くなると、投げる速度も自動で落ちる」前提の数字です。現実のユーザーは、サーバーが遅かろうが容赦なくアクセスしてきます(オープンループ)。だから本番のほうが、abの数字より悪く出ることがありますabは同じURLを叩き続けるので、キャッシュに当たりやすく、本番より良く出がちでもあります
では ab の数字は無意味か——いいえ。「同じ条件で、Before と After を比べる」目的には、完璧に使えます。 絶対値を「本番でもこの速さ」と請け合うのには向きませんが、「索引を張ったら29倍になった」という相対の証拠としては、これで十分です。この記事で欲しいのは、まさにその相対の証拠です。
平均を見るな、p95 を見ろ
ab は Time per request ... (mean) に平均も出しますが、この平均は当てになりません。
平均が仮に 1300ms でも、それは「みんな 1300ms 待った」という意味ではありません。速い人は 400ms、遅い人は 2600ms で、それをならしただけです。ユーザーが感じるのは平均ではなく、自分に当たった、その1回です。
- p50(中央値)= 1250ms——半分の人は、これより速い
- p95 = 2100ms——20人に1人は、2.1秒待たされている
- p99 = 2600ms——100人に1人は、2.6秒。トップページなら、これで離脱します
「平均が良くても p95 が崩れている」——これが、台数を増やしたら遅くなった — システム設計深掘り で見た、尾(テール)のレイテンシです。改善したかどうかは、平均ではなく p95・p99 で判定します。 これを紙に書いておきます。ここが「Before」です。
④ ボトルネックを1つ特定する
数字は出ました。次は「なぜ遅いか」を、証拠で名指しします。 ここで当てずっぽうをやめます。
詰まる場所の候補は、だいたい4つです。このうち、一番詰まっている1つを見つけます。
- CPU——計算が重い(アプリの処理、DBの走査)
- メモリ——足りずにスワップしている
- ディスクI/O——読み書きが追いつかない
- DB——クエリが遅い、コネクションが足りない
「たぶんこれ」で選ばず、道具で1つに絞ります。 どの道具で何を見て、どう読むか——この早見表のとおりに進めます。
| 疑う場所 | 見る道具 | 詰まっているサイン |
|---|---|---|
| CPU | top | 特定プロセスの %CPU が 100 を大きく超える(コアを食い尽くしている) |
| メモリ | vmstat 1 | si/so(スワップ)が 0 より大きい。free が極端に小さい |
| ディスクI/O | vmstat 1 | wa(I/O待ち)が高い。bi/bo が張り付く |
| DB | SHOW FULL PROCESSLIST | 同じクエリが何本も executing で滞留している |
| DBのクエリ | EXPLAIN / スロークエリlog | type=ALL(全表走査)、query_time が大きい |
上から順に見て、当てはまった1つが、いまのボトルネックです。 複数が同時に赤く見えても、たいてい根っこは1つ——今回なら「索引の無い全表走査」が、CPU も DB も同時に赤くしています。原因の木の、一番下を狙います。
top で「誰がCPUを食っているか」を見る
負荷をかけている最中に、別ターミナル(3枚目、または2枚目で ab を回しながら)で top を開きます。
[スクリーンショット: 02_top_mysqld.png] ab で負荷をかけている最中の top を撮ってください。mysqld の %CPU が高く、node が低いことが写るようにしてください。
負荷中は、こんな並びになります。
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
1042 mysql 20 0 1680000 420000 18000 S 188.3 10.5 3:20.11 mysqld
1550 bench 20 0 620000 62000 22000 S 12.0 1.6 0:08.44 node
これが証拠です。
mysqldが %CPU 188——CPU を2本近く、丸ごと食っています(abの50接続 → プールの10接続が、10本の全表走査を同時に走らせている)nodeは %CPU 12——アプリ側は、ほぼ暇。待っているだけです
つまり、ボトルネックは Node.js ではなく、MySQL の全表走査です。アプリのコードをいくらいじっても、1ミリも速くなりません。 ここを間違えて「Node を速くしよう」とすると、当てずっぽうの罠にはまります。
vmstat で「スワップしていないか」を確かめる
念のため、メモリとディスクも見ておきます。除外するために見ます。
procs -----------memory---------- ---swap-- -----io---- --system-- ------cpu-----
r b swpd free buff cache si so bi bo in cs us sy id wa st
10 0 0 210000 15000 980000 0 0 0 12 900 1800 82 10 8 0 0
si/so(スワップ)が 0——メモリは足りている。メモリはボトルネックではないwa(I/O待ち)が 0——ディスク待ちも起きていない。データはメモリ(バッファプール)に載っているus(ユーザーCPU)が 82——CPU で焼けている。topの結論と一致
メモリでもディスクでもなく、CPU。 そして CPU を食っているのは MySQL。ここまでで、候補4つのうち3つを消し、1つに絞れました。
DBに聞く——何のクエリで詰まっているか
最後に、MySQL 自身に「いま何をしているか」を聞きます。負荷の最中に、別ターミナルで:
SHOW FULL PROCESSLIST;
+----+-------+-----------+-----------+---------+------+--------------+-------------------------------------------+
| Id | User | Host | db | Command | Time | State | Info |
+----+-------+-----------+-----------+---------+------+--------------+-------------------------------------------+
| 51 | bench | localhost | bench_cap | Query | 1 | executing | SELECT id, amount, created_at FROM orders |
| 52 | bench | localhost | bench_cap | Query | 1 | executing | SELECT id, amount, created_at FROM orders |
| 53 | bench | localhost | bench_cap | Query | 0 | executing | SELECT id, amount, created_at FROM orders |
+----+-------+-----------+-----------+---------+------+--------------+-------------------------------------------+
同じクエリが、何本も同時に走って executing(実行中。MySQL 8.0.17 より前は Sending data と表示されていた状態)で詰まっているのが見えます。これが「遅いクエリ」の現行犯です。
もっとちゃんと記録したいときは、スロークエリログを一時的にONにします。ファイルではなくテーブルに出すようにしておくと、パスを触らずに済みます。
SET GLOBAL slow_query_log = 'ON';
SET GLOBAL log_output = 'TABLE';
SET GLOBAL long_query_time = 0.1;
この状態でもう一度 ab を回してから、遅かったクエリを一覧します。
SELECT start_time, query_time, LEFT(sql_text, 40) AS sql_text
FROM mysql.slow_log
ORDER BY query_time DESC
LIMIT 5;
+---------------------+-----------------+------------------------------------------+
| start_time | query_time | sql_text |
+---------------------+-----------------+------------------------------------------+
| 2026-10-16 09:12:03 | 00:00:00.284000 | SELECT id, amount, created_at FROM order |
| 2026-10-16 09:12:03 | 00:00:00.271000 | SELECT id, amount, created_at FROM order |
+---------------------+-----------------+------------------------------------------+
犯人が確定しました。 WHERE customer_id = ? のクエリが、1本あたり 0.28 秒。これが50接続で殺到して、CPU を焼き、p95 を 2.1 秒に押し上げていました。
もう1つの落とし穴(今回は原因ではない)。 アプリの
app.jsはconnectionLimit: 10で、MySQL に同時につなげる本数を10本に絞っています。 もし「MySQL の CPU は暇なのに、API だけ遅い」なら、疑うのはこのプールの枯れです。50人が来ても、DBに届くのは10本まで。残り40人は空きが出るのを待って行列します。これも立派なボトルネックの一種で、直し方は「プールを広げる」か「1本あたりを速くする」。今回はtopで mysqld が焼けていた=DB自身が詰まっていたので、プールを広げても悪化するだけです。症状が似ていても、証拠が指す場所が違えば、直す場所も違う——ここでも「測ってから」です。
ここで「1つに絞る」のが山場です。 CPU も高いし、DB も詰まっている——ように見えて、根っこは1つ(索引の無い全表走査)です。その1つだけを、次で潰します。
スロークエリログは、後で戻します(後片づけで消します)。MySQL を出ておきます。
EXIT;
⑤ 1つだけ潰して、また測る
特定できたボトルネックは、たった1つ——customer_id に索引が無いこと。今回直すのは、これだけです。 キャッシュも入れないし、プロセスも増やしません。1回の改善で変えるのは1つ、を守ります。
索引を1本張る
MySQL に入って、customer_id と created_at の複合索引を張ります。ORDER BY created_at も効かせたいので、2列まとめて張るのがコツです。
CREATE INDEX idx_customer_created ON orders (customer_id, created_at);
「使われるようになったか」を、EXPLAIN で確かめます。 「張った」と「使われた」は別物です。
EXPLAIN
SELECT id, amount, created_at
FROM orders
WHERE customer_id = 4242
ORDER BY created_at DESC
LIMIT 20;
+----+-------------+--------+------+----------------------+----------------------+---------+-------+------+-------------+
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+----+-------------+--------+------+----------------------+----------------------+---------+-------+------+-------------+
| 1 | SIMPLE | orders | ref | idx_customer_created | idx_customer_created | 4 | const | 48 | Backward index scan|
+----+-------------+--------+------+----------------------+----------------------+---------+-------+------+-------------+
3つとも変わりました。
typeがALL→ref——全表走査をやめ、索引で一本釣りrowsが 498210 → 48——読む行が 50万から48。1万分の1ExtraのUsing filesortが消えた——並べ替えも索引が済ませてくれた(Backward index scan)
クエリ1本の時間も、ここで見ておきます。MySQL クライアントは、実行のたびに (0.28 sec) のように所要時間を表示してくれます。索引を張る前後で、同じSELECTを1本打って比べます。
SELECT id, amount, created_at
FROM orders
WHERE customer_id = 4242
ORDER BY created_at DESC
LIMIT 20;
20 rows in set (0.002 sec)
索引前は (0.28 sec) 前後だったものが、(0.002 sec) になりました。 クエリ1本で 140 倍。これが、負荷をかけたときの「スループット29倍・p95 が22分の1」の正体です。ただし、1本の時間だけを見て安心してはいけません。 1本が速くても、50人が同時に来たときにどうなるかは、負荷をかけないと分かりません。だから、この後もう一度 ab で測ります。
APIはそのまま(1行も変えていません)、同じ負荷で測り直します。
EXIT;
同じ負荷で、もう一度測る
Before と After は、まったく同じ条件で測らないと比べられません。 -n 2000 -c 50、同じ customer=4242。ウォームアップも同じようにやってから、本番を打ちます。
1回だけの結果を信じない、というのも大事です。 同じ条件でも、他のプロセスの都合で数字は少しブレます。本番の測定は2〜3回打って、ばらつきが小さいことを確かめてから、代表値を採ります。もし毎回大きく違うなら、それは「まだ何か別の要因が動いている」合図で、結論を出す前に原因を1つ潰します。今回は、索引の効果が桁で出るので、1回でも傾向は明らかですが——桁で動かない改善こそ、複数回測って確かめる必要があります。
[スクリーンショット: 03_after_ab.png] 索引を張った後の ab の結果を撮ってください。Requests per second が大きく増え、95% の値が小さくなっていることが写るようにしてください。
Concurrency Level: 50
Time taken for tests: 1.818 seconds
Complete requests: 2000
Failed requests: 0
Requests per second: 1100.11 [#/sec] (mean)
Time per request: 45.450 [ms] (mean)
Percentage of the requests served within a certain time (ms)
50% 38
75% 52
90% 78
95% 95
99% 160
100% 240 (longest request)
Before / After を1枚の表にする
これが、この記事の成果物です。 感想ではなく、数字を並べます。
| 指標 | 索引なし(Before) | 索引あり(After) | 改善 |
|---|---|---|---|
| スループット | 38 req/s | 1100 req/s | 約29倍 |
| p50 | 1250 ms | 38 ms | 約33分の1 |
| p95 | 2100 ms | 95 ms | 約22分の1 |
| p99 | 2600 ms | 160 ms | 約16分の1 |
EXPLAIN の type | ALL(全表走査) | ref(索引で一本釣り) | — |
EXPLAIN の rows | 498210 | 48 | 約1万分の1 |
「速くなった」ではなく、この表で言えるようになりました。 ——「p95 が 2100ms から 95ms になった。理由は全表走査(type=ALL・50万行)が索引参照(type=ref・48行)に変わったから。証拠は EXPLAIN と top」。
この表は、消さずに残します。 改善の記録は、テキストで1行残しておくと、後の自分を助けます。 「いつ・何を・どの数字が・どう変わったか」を、こんな形でメモに追記していくだけで十分です。
2026-10-16 orders API
変更: orders(customer_id, created_at) に索引を1本
Before: 38 req/s / p95 2100ms / EXPLAIN type=ALL rows=498210
After : 1100 req/s / p95 95ms / EXPLAIN type=ref rows=48
次のボトルネック: node が1コア100%(top で確認)
半年後に「なぜこの索引があるのか」と聞かれたとき、この4行が答えになります。 索引の理由が「誰かが昔張ったから」ではなく「この数字のため」と言える——それが、測って直したことの、もう1つの成果です。
他の直し方もあったことは、頭の隅に置いておきます。今回は索引が一番素直でしたが、キャッシュを入れたのに速くならない — システム設計深掘り で見たキャッシュも、同じ「DBに聞く回数を減らす」手でした。ただし、索引で 95ms まで下がったのに、さらにキャッシュを重ねるのは、この段階では過剰です。理由は次で分かります。
⑥ 次のボトルネックは、別の場所へ動いた
1つ潰したら終わり、ではありません。 ボトルネックは、潰すと別の場所へ移ります。 それを確かめます。
索引を張った後の負荷中に、もう一度 top を見てください。
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
1550 bench 20 0 640000 70000 22000 R 99.3 1.8 1:12.30 node
1042 mysql 20 0 1680000 430000 18000 S 22.6 10.7 3:41.02 mysqld
立場が入れ替わりました。
- さっきまで暇だった
nodeが、%CPU 99——1コアを使い切っています - さっきまで焼けていた
mysqldは、%CPU 22 に下がった
ボトルネックが、MySQL から Node.js へ移ったのです。理由は、ボトルネックは動く — 負荷分散とキャッシュの設計 で見たとおり——Node.js の1プロセスは、CPUを1コアしか使いません。 DBが速くなって、今度はアプリの処理そのものが上限になったわけです。
ここで「止めどき」を決める
初心者がやりがちな失敗は、ここでNodeも速くしようと、闇雲に次の改善へ突っ込むことです。でも、止めるべきかどうかは、要件が決めます。
- もし要件が「p95 を 200ms 以下」なら——もう達成しています(95ms)。ここで止めます。 これ以上の改善は、いま要らない仕事です
- もし要件が「1秒に3000件」なら——1100 req/s では足りない。次のボトルネック(Nodeの1コア)を潰しに行きます
では、その「要件の数字」はどう決めるのか。 目安は、ユーザーがどう感じるかから逆算します。細かい根拠より、この肌感で十分です。
| レイテンシ(p95) | ユーザーの感じ方 | どうすべきか |
|---|---|---|
| 100ms 以下 | 一瞬。ひっかかりを感じない | 十分。ここまでで止めてよい |
| 100〜300ms | 「すっと出た」。快適 | 多くの画面はここが目標 |
| 300ms〜1秒 | 「ちょっと待つ」。気になり始める | 主要な画面なら改善したい |
| 1秒〜3秒 | 「遅い」。離脱が増える | Before はここだった。要改善 |
| 3秒以上 | 「壊れてる?」。多くが離脱 | 即・直す |
索引を張った後の p95 は 95ms。上の表なら「一瞬」の域です。トップページの一覧としては、もう十分すぎる——だから止める、という判断ができます。要件は、こうやって体感から先に決めて、測った数字と突き合わせるものです。
「全部を最速にする」という要件は、現実には存在しません。 速くするほどコードは複雑になり、壊れやすくなります。目標の数字を満たしたら、そこで手を止めるのが、正しい設計判断です。
もし本当に次を潰すなら、道はもう見えています(今回はやりませんが、地図として)。
- Node を2プロセス動かして nginx で振り分ける——ボトルネックは動く — 負荷分散とキャッシュの設計 の続き。1コアの壁を、台数(プロセス数)で越える
- 同じ答えを何度も返すなら、手前で覚える——キャッシュを入れたのに速くならない。ただしキャッシュには「古い値が返る」代償がつく
- 読み取りが増えたら、読み専用の複製を足す——書いた直後に読むと無い — レプリケーションとCAP。複製にも「書いた直後は古い」代償がある
- 重い処理を、その場で待たせない——1つの遅い処理が全部を止める — システム設計深掘り。返事を先に返して、処理は後ろに回す
選ぶ順番にも、コツがあります。 安くて副作用の小さいものから試します。
- まず、いまの構成のままできること(索引、クエリの書き換え、プロセス数)——お金も新しい部品も要らない
- 次に、部品を1つ足すこと(キャッシュ、読み専用の複製)——古い値が返るなどの代償が付くので、要件と相談
- 最後に、構成を変えること(非同期化、サービス分割)——効果は大きいが、複雑さも大きい
いきなり3番目に飛ばないのが鉄則です。索引1本(1番目)で足りるのに、キューやマイクロサービス(3番目)を持ち出すのは、遅い原因は推測では当たらない — システム設計深掘り で見た「効かない過剰設計」そのものです。
どれを選ぶかは、また「測ってから」です。 次に詰まる場所を数字で確かめてから、1つだけ潰す。同じループが、ずっと続きます。
⑦ 完成の判定
「なんとなく速くなった」で終わらせないために、チェックリストを自分で通します。 全部にチェックが付いたら、この到達作品は完成です。
- [ ] わざと遅いAPIを立て、負荷をかけて p95 を数字で測れた(Before の表がある)
- [ ] 平均ではなく p95・p99 を記録した(平均だけで判断していない)
- [ ] ボトルネックを1つ、証拠付きで特定できた(
topの %CPU、EXPLAINのtype=ALL、プロセス一覧のどれか) - [ ] その1つだけを直した(索引1本。他は何も変えていない)
- [ ] 同じ負荷で測り直し、Before/After を1枚の表にできた(スループット・p95・p99 が並んでいる)
- [ ] 数字が実際に改善した(p95 が 2100ms → 95ms のように、桁で動いた)
- [ ] 「次のボトルネックはどこか」を予想できる(
topで Node が 1コアを使い切ったのを見た) - [ ] 止めどきを、要件で言える(「p95 200ms 以下なら達成なので止める」と言える)
一番大事なのは、上から3つ目と4つ目です。 「証拠付きで1つ特定」して「その1つだけ直す」——ここが、当てずっぽうとの分かれ目です。ここができていれば、題材が索引でもキャッシュでもプロセス数でも、同じやり方で潰せます。
もし1つでもチェックが付かないなら、そこがこの記事の本題です。 「p95 を測っていない(平均で判断した)」なら③へ、「証拠なしで直した」なら④へ、戻ってやり直します。チェックリストは、できたことを確認する道具であると同時に、どこで手を抜いたかを教えてくれる道具でもあります。全部埋まって初めて、「測って直せる人」になったと言えます。
つまずいたところ
1発目だけ異常に遅くて、Before の数字が安定しなかった。 ウォームアップを飛ばすと、MySQL のバッファプールが冷えていて、最初の数十リクエストだけ極端に遅く出ます。それが p99 を吊り上げていました。先に ab -n 200 -c 10 で空回ししてから本番を測ったら、値が安定しました。
top を見たら node が高くて、「アプリが原因だ」と早合点した。 よく見たら、それは索引を張った後の top でした。Before の詰まりを見るなら、Before の負荷中に top を見る——順番を間違えると、直す場所を取り違えます。測るタイミングも、揃えます。
索引を張ったのに、p95 がほとんど変わらなかった。 EXPLAIN を見たら type=ALL のまま。原因は、customer_id ではなく間違えて amount に索引を張っていたことでした。「張った」と「使われた」は別——EXPLAIN の key に、張った索引の名前が出て初めて「使われた」です。
ORDER BY のせいで Using filesort が残り続けた。 最初 customer_id だけの単一列索引を張ったら、絞り込みは速くなったのに並べ替えが残っていました。(customer_id, created_at) の複合索引にしたら filesort が消えました。索引は「WHERE と ORDER BY の両方」を意識して張ります。
ab の URL の ? を、シェルが勝手に展開しようとした。 ab -n 2000 -c 50 http://.../orders?customer=4242 をクォート無しで打つと、? がファイル名のパターンとして扱われて事故ります。URL全体をダブルクォートで囲むと直りました。
Before と After で、違う顧客IDを叩いてしまって比較にならなかった。 customer=4242 と customer=99 では、返る件数も分布も違います。Before/After は、URLも -n も -c も1文字残らず同じにして、初めて比べられます。
負荷をかけている最中に、SSH が重くて top が開けなかった。 同じVMで、APIも MySQL も ab も動かしているので、当然です。ab の総数を -n 2000 くらいに抑えて、短時間で終わらせてから、または3枚目のターミナルを先に開いておいて top を見るようにしました。負荷試験は、測定側もリソースを食うことを忘れないようにします。
Failed requests が0以外になって、数字の意味を疑った。 ab は、レスポンスの長さがリクエストごとに違うと、それを「失敗」と数えることがあります。今回は顧客ごとに返る件数が違うので、長さがばらつくのが原因でした。中身のエラー(HTTP 500 など)ではなく長さの差なら、ab の Non-2xx responses が0であることを確認すれば、実害はありません。
-c を上げても、スループットが全然変わらず「壊れた?」と思った。 それが正常でした。天井に当たったあとは、-c を増やしてもスループットは増えず、p95 だけが伸びます。 「増やしたのに速くならない」こと自体が、ボトルネックに当たっている証拠です。ここを「ツールの不具合」と誤解しないようにします。
索引を張ったあとの top を見て、「MySQL を直したのに、まだ何か100%だ」と焦った。 100% だったのは Node のほうでした。ボトルネックが移っただけで、故障ではありません。⑥のとおり、これは「次の課題が見えた」という健全な状態です。どのプロセスが赤いのかを、COMMAND 列でちゃんと読みます。
WITH RECURSIVE の行生成が、途中で Recursive query aborted で止まった。 再帰の深さの上限(cte_max_recursion_depth)の既定は 1000 なので、50万まで回すと途中で止まります。SET SESSION cte_max_recursion_depth = 1000000; を先に打つのを忘れていました。これは SESSION 指定なので、接続を切れば元に戻ります。
「速くなった」と喜んだが、Before の数字を書き留めていなかった。 After だけ見て「速い」と言っても、どれだけ速くなったかを言えません。 Before の p95 をメモしていなかったので、測り直すはめになりました。測ったら、その場で紙(かメモ)に書く——後で思い出せる、は思い込みでした。
索引を張る CREATE INDEX が、一瞬でも返ってこず不安になった。 50万行なら1〜2秒ですが、待っている間「固まった?」と不安になりました。索引作成は、行数に比例して時間がかかる——数千万行なら数分かかることもある、と知っていれば慌てません。本番では、この時間も「測る」対象です。
スロークエリログをONにしたまま忘れそうになった。 SET GLOBAL はサーバー全体に効くので、練習が終わったら戻さないと、余計なログが溜まり続けます。後片づけで必ず OFF に戻す、とメモしました。
後片づけ
練習用の一式を、全部消します。 アプリを止めて、データベースとユーザーを消し、スロークエリログを元に戻します。消すのは、この記事で作ったものだけです。既存のデータベースには最初から一切触れていないので、安全です。
まず、APIを止めます。node app.js を動かしているターミナルで Ctrl+C を押します。
次に、MySQL で、この記事で作ったものだけを消します。
DROP DATABASE bench_cap;
DROP USER 'bench'@'localhost';
DROP DATABASE は取り消せません。 ですが、消すのは bench_cap だけです。念のため、消す前に一覧を見て、bench_cap 以外に手をかけていないことを確かめると安心です。
一時的にONにしたスロークエリログを、元に戻します。
SET GLOBAL slow_query_log = 'OFF';
SET GLOBAL log_output = 'FILE';
SET GLOBAL long_query_time = 10;
long_query_time の既定は 10 秒です。0.1 に下げたままだと、通常運用で余計なログが増えるので、10 に戻します。MySQL を出ます。
EXIT;
作業フォルダを消します。
負荷試験ツールは、また使うなら残して構いません。もう使わないなら消せます。
確認します。bench_cap が消えていれば片づけ完了です。
本物のアプリでやるときの注意
この「測る → 特定 → 潰す → また測る」の型は、あなたの実際のアプリにもそのまま使えます。 ただし、練習用の bench_cap と違って、本番には人のデータと、本物のユーザーがいます。4つだけ守ってください。
- 本番サーバーに、いきなり
abを撃たない。 負荷試験は、本物のユーザーへの立派な妨害になります。測るのは、本番と同じ構成のコピー(ステージング)か、アクセスの少ない時間帯の隔離環境でやります CREATE INDEXは、大きなテーブルだと数秒〜数分、テーブルを重くすることがあります。本番で張るなら、アクセスの少ない時間帯にします。今回のように50万行なら一瞬ですが、数千万行では別の話です- スロークエリログや
long_query_timeを触ったら、必ず元に戻す。SET GLOBALはサーバー全体に効きます。下げっぱなしにすると、通常運用でログが溜まり続けます - 1つ潰したら、また測る。1度に複数を直さない。 本番でこそ、この規律が効きます。索引・キャッシュ・プロセス増を一気に入れて速くなっても、次に遅くなった時、どれを疑えばいいか分からなくなるからです
負荷試験そのものも、リソースを食う道具だということも忘れないようにします。ab を撃つマシンと、測られるサーバーが同じVMだと、ab 自身がCPUを奪って、数字が悪いほうにずれます。 本気で測るなら、負荷をかける側は別のマシンから撃ちます。今回は「桁で動く」のを見るのが目的なので同居で十分でしたが、細かい数字を詰めるときは、測定側の影響を切り離します。
まとめ — 理解できたこと
- システム設計深掘りコースの到達点は、「測って、1つ潰して、数字で示す」ループを一人で回せることだった。埋めたのは、Before/After の数字が入った表1枚
- 「速くする前に必ず測る」の意味。 測らずに直すと、効いたのか偶然か、永久に分からない。当てずっぽうは、当たった時だけ正しく見える危ない博打
- 平均は嘘をつく。 平均が良くても、p95・p99 は崩れていることがある。ユーザーが感じるのは平均ではなく、自分に当たった1回。改善の判定は p95・p99 でやる
- 負荷をかけないと、遅さは見えない。 1人で開いて速いのは、行列がまだ無いから。詰まりは同時接続(
-c)を増やして初めて現れる - ボトルネックは1つずつしか潰せない。 CPU・メモリ・ディスクI/O・DBのうち、一番詰まっている1つを直す。他を直しても、全体は1ミリも速くならない
- 証拠でボトルネックを名指しする。
topの %CPU(mysqld が焼けている)、vmstatのsi/so/wa(スワップもI/O待ちも無い=CPU)、EXPLAINのtype=ALL、プロセス一覧のexecuting——感覚ではなく、証拠を1つ挙げる - 1回の改善で、変えるのは1つ。 索引も張ってキャッシュも入れて、では、どれが効いたか分からない。今回は索引を1本だけ張った
- 索引が「速い」の正体は、
type=ALL(全表走査)がtype=ref(索引で一本釣り)に変わること。 速さは結果で、本質は読む行数(rows)が 50万 → 48 に減ること - 同じ負荷で測り直して、初めて比べられる。
-n・-c・URLを1文字も変えずに測る。Before/After は同じ条件が命 - 数字で言える。 「p95 が 2100ms → 95ms。理由は全表走査が索引参照に変わったから。証拠は
EXPLAINとtop」——これが、この記事の成果 - ボトルネックは動く。 MySQL を潰したら、次は Node.js の1プロセス(1コア)が 99% に張り付いた。銀の弾丸は無い
- 止めどきは、要件が決める。 「p95 200ms 以下」なら 95ms で達成——そこで手を止める。全部を最速にする要件は現実に存在しない。闇雲に全部速くしない
- 次の一手も、また「測ってから」。 プロセス増(負荷分散)・キャッシュ・読み書き分離・非同期——どれを選ぶかは、次に詰まる場所を数字で見てから、1つだけ
- この型は、索引でなくても同じ。 題材がキャッシュでも同期I/Oでも N+1 でも、「測る → 1つ特定 → 潰す → また測る」は変わらない。それを50万行で体に入れたのが、この到達作品
- 記録を1行残すと、半年後の自分を助ける。 「いつ・何を・どの数字が・どう変わったか」。索引の理由が「数字のため」と言えるようになる
- 完成の判定を自分で持つと、「なんとなく速い」で終わらない。チェックリストの8個を、証拠付きで通せた
この記事でやったことを、1枚に畳むと、こうなります。
| 手順 | 使った道具 | 見た数字(Before → After) |
|---|---|---|
| ① 測る | ab -n 2000 -c 50 | p95 2100ms(記録した) |
| ② 崩れる点を探す | -c を 1→100 に振る | -c 25 で p95 が跳ねる/天井 38 req/s |
| ③ 1つ特定 | top / vmstat / EXPLAIN | mysqld %CPU 188・type=ALL・rows 498210 |
| ④ 1つ潰す | CREATE INDEX(1本だけ) | type=ref・rows 48・1本 0.28→0.002 sec |
| ⑤ また測る | 同じ ab | p95 2100 → 95ms/38 → 1100 req/s |
| ⑥ 次を見る | top | node %CPU 99(次のボトルネックへ移動) |
システム設計は、図を眺めるものではありませんでした。 自分のサーバーに負荷をかけ、どこが先に音を上げるかを数字で捕まえ、1つだけ直して、また測る。この地味なループが、実践のシステム設計そのものです。図はここから、初めて意味を持ちます。
そして、次に学ぶこと
この記事で潰したのは、たまたま索引の無いクエリ1本でした。 でも、身についたのは索引の知識ではありません。「測る → 1つ特定 → 潰す → また測る」というループです。これは、この先どんな遅さにも効きます。
- さらに負荷が増えて Node の1コアが限界なら——ボトルネックは動く — 負荷分散とキャッシュの設計 で、プロセスを増やして nginx で振り分けます
- 同じ答えを何度も返しているなら——キャッシュを入れたのに速くならない で「そもそもDBに聞かない」を考えます。ただしキャッシュには「古い値が返る」代償がつきます
- 読み取りだけが増えているなら——書いた直後に読むと無い — レプリケーションとCAP で、読み専用の複製を足します。複製にも「書いた直後は古い」代償があります
- 重い処理をその場で待たせているなら——1つの遅い処理が全部を止める で、返事を先に返して処理を後ろに回します
共通しているのは、この記事でやったこと——「先に測る」——です。 索引でも、プロセス増でも、キャッシュでも、複製でも、非同期でも、測らずに足したものは、効いたかどうか永久に分かりません。 それを、50万行とVM1台で体に入れたのが、このシステム設計深掘りの到達作品でした。
参考リンク
- roadmap.sh — System Design
- roadmap.sh — Backend
- Node.js ドキュメント — HTTP モジュール
- Node.js ドキュメント — perf_hooks(処理時間の計測)
- MDN 用語集 — Latency(レイテンシ)
- MySQL 8.0 リファレンス — EXPLAIN の使い方
- MySQL 8.0 リファレンス — スロークエリログ
- MySQL 8.0 リファレンス — MySQL が索引を使う仕組み
この段階の確認
【深掘り】システム設計 は、ここで終わりです。 次に進む前に、答えを見ずに試してください。
読み終えた直後は、たいてい「分かった気」になっています。 手が動くかどうかは別です。
説明できますか
- 設計は図からではなく数から始める。 最初に見積もるものは何か
- 99.9% は月に何分の停止か。 その数字で何を決めますか
- 台数を増やしたら遅くなったのはなぜか
手が動きますか
- キャッシュを置く層を選び、なぜそこなのかを説明する
- 負荷をかけ、ボトルネックが移動することを測る
- リトライに指数バックオフを入れ、障害を長引かせないようにする
1つでも詰まったら、飛ばした回があります。 そこへ戻ってください。戻るのは後退ではありません。 戻り先の目安: 設計の進め方の回 / キャッシュの層の回 / 可用性とSLOの回
全部答えられたなら、次の段階へ進んでください。
次に読む
この記事は 【深掘り】システム設計 の 17 / 17 本目です。
上から順に読めば積み上がるように並べています。 飛ばしても構いませんが、詰まったら前の回に戻ってください。
全体の順路は はじめに にあります。
roadmap.sh のどこをやっているか
【深掘り】システム設計の到達作品です。 遅いアプリを負荷試験で測り、ボトルネックを特定して直し、Before/After を数字で示します。

コメント