推測で直さず測って潰す — システム設計の到達作品

システム設計の到達作品。サーバーとストップウォッチ、虫眼鏡と測定ノート。

システム設計の記事を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 が、原因の「証拠」になること。感覚ではなく証拠でボトルネックを名指しできること

この記事でやること

  1. わざと遅いAPIを立てる——MySQL に 50万行を作り、索引の無い列で絞る Node.js のAPIを1つ動かす
  2. 負荷試験ツール ab を入れて、いまの数字を出す——スループットと p50・p95・p99 を記録する
  3. ボトルネックを1つ特定する——top / vmstat / MySQL のプロセス一覧・スロークエリで、CPU・DBのどこが詰まっているかを切り分ける
  4. ボトルネックを1つだけ潰す——CREATE INDEX を1本張る(他は何も変えない)
  5. 同じ負荷で測り直し、Before/After を1枚の表にする——スループット・p95・p99 を並べる
  6. 次のボトルネックがどこへ移ったかを確かめる——top を見て、止めどきを要件で決める
  7. 完成の判定(チェックリスト)を自分で通し、練習用の一式を消す

先に知る言葉

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

言葉意味
スループット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歩です。

  1. 測る——いまの数字(スループット・p95・p99)を紙に書く
  2. 1つ特定する——どこが詰まっているか、証拠を1つ挙げる
  3. 潰す——その1つだけを直す。他は触らない
  4. また測る——同じ負荷で測り直し、数字が動いたか見る

③と④の間に何本も直してはいけません。 索引も張ってキャッシュも入れてプロセスも増やして、それで速くなっても、どれが効いたのか分からないからです。1回の改善で、変えるのは1つ。これが鉄則です。

図にすると、こういう円を回すだけです。

   ┌─────────────────────────────────────────────┐
   │                                             │
   ▼                                             │
 ① 測る ──▶ ② 1つ特定 ──▶ ③ その1つだけ潰す ──▶ ④ また測る
(数字を書く)(証拠を挙げる)(他は触らない)    (数字が動いたか)
   │                                             │
   │  要件を満たした? ── はい ──▶ 止める(完成)    │
   └── いいえ ────────────────────────────────────┘
                        (次のボトルネックへ、また①から)

止まる条件は「速くなった」ではなく「要件を満たした」です。 ここを混同すると、いつまでも終わらない改善に沈みます。速さには上限がなく、要件には上限があります。この円のどこで降りるかを決めるのが、この記事の裏テーマです。

この「測ってから直す」は、速くする前に必ず測る — パフォーマンス改善とEXPLAIN で SQL 1本に対してやったことと、同じ型です。今回はそれを、API全体・負荷ありでやります。そして、遅い原因は推測では当たらない — システム設計深掘り で「当たらない」と言い切った理由を、今日は自分の手で確かめます。

合言葉は1つ。「測ってから直す」。 これができれば、この記事は半分終わっています。

測る道具を、先に3つそろえる

「測る」と言っても、道具がないと何も見えません。この記事で使う道具は、たった3種類です。何を見る道具か、先に頭に入れておきます。

道具何を測るかいつ使うか
abAPI全体の速さ(スループット・p95・p99)③・⑤——外から負荷をかけて測る
top / vmstatどのプロセスが、CPU・メモリ・I/Oを食っているか④——負荷の最中に、詰まりの場所を見る
EXPLAIN / スロークエリlogDBが、どのクエリで、どう詰まっているか④——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 を作るだけです。

VMの中(Ubuntu Server)
$ sudo mysql

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 を打ちます。

VMの中(Ubuntu Server)
$ sudo mysql bench_cap
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を書きます。作業用のフォルダを作って入ります。

VMの中(Ubuntu Server)
$ mkdir ~/bench-cap
$ cd ~/bench-cap
$ npm init -y
$ npm install mysql2

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"));

起動します。

VMの中(Ubuntu Server)
$ node app.js

listening on http://127.0.0.1:3000 と出れば動いています。このターミナルはAPIを動かしっぱなしにするので、負荷試験は別のターミナル(もう1枚 SSH でVMに入る)で打ちます。

別ターミナルから、1回だけ叩いて、中身が返ることを確認します。

VMの中(Ubuntu Server・2枚目)
$ curl "http://127.0.0.1:3000/orders?customer=4242"

JSON の配列が返れば成功です。1回だと、たぶん一瞬で返ります。 ここが罠です。1人で速いことは、何の保証にもなりません。 次で、50人にします。


③ 負荷をかけて、数字を出す

ここからが本番です。 1人では見えなかった詰まりを、同時接続を増やして引きずり出します。

負荷試験ツールを入れる

ab(Apache Bench)を使います。ab は素のUbuntuには入っていません。 apache2-utils パッケージに入っているので、apt で入れます。

VMの中(Ubuntu Server・2枚目)
$ sudo apt update
$ sudo apt install -y apache2-utils

入ったか確認します。バージョンが出れば成功です。

VMの中(Ubuntu Server・2枚目)
$ ab -V

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 のバッファプールが冷えていて、遅く出ます。軽く空回しして温めます。

VMの中(Ubuntu Server・2枚目)
$ ab -n 200 -c 10 "http://127.0.0.1:3000/orders?customer=4242"

この数字はメモしません。ウォームアップです。

本番の負荷をかける

2000リクエストを、50人同時で送ります。-n が総リクエスト数、-c が同時接続数です。

VMの中(Ubuntu Server・2枚目)
$ ab -n 2000 -c 50 "http://127.0.0.1:3000/orders?customer=4242"

[スクリーンショット: 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 second38 req/s
p50(中央値)50% の行1250 ms
p9595% の行2100 ms
p9999% の行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 だけを変えて何回か回します。

VMの中(Ubuntu Server・2枚目)
$ ab -n 100  -c 1   "http://127.0.0.1:3000/orders?customer=4242"
$ ab -n 400  -c 10  "http://127.0.0.1:3000/orders?customer=4242"
$ ab -n 1000 -c 25  "http://127.0.0.1:3000/orders?customer=4242"
$ ab -n 2000 -c 50  "http://127.0.0.1:3000/orders?customer=4242"
$ ab -n 2000 -c 100 "http://127.0.0.1:3000/orders?customer=4242"

各回の Requests per second と 95% の行だけ拾って、並べます。

同時接続 -cスループットp95様子
16 req/s180 ms1人なら普通に返る
1033 req/s480 msまだ耐えている
2537 req/s1100 msp95 が跳ね始めた
5038 req/s2100 msスループットは頭打ち、待ち時間だけ倍増
10038 req/s4300 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つに絞ります。 どの道具で何を見て、どう読むか——この早見表のとおりに進めます。

疑う場所見る道具詰まっているサイン
CPUtop特定プロセスの %CPU が 100 を大きく超える(コアを食い尽くしている)
メモリvmstat 1si/so(スワップ)が 0 より大きい。free が極端に小さい
ディスクI/Ovmstat 1wa(I/O待ち)が高い。bi/bo が張り付く
DBSHOW FULL PROCESSLIST同じクエリが何本も executing で滞留している
DBのクエリEXPLAIN / スロークエリlogtype=ALL(全表走査)、query_time が大きい

上から順に見て、当てはまった1つが、いまのボトルネックです。 複数が同時に赤く見えても、たいてい根っこは1つ——今回なら「索引の無い全表走査」が、CPU も DB も同時に赤くしています。原因の木の、一番下を狙います。

top で「誰がCPUを食っているか」を見る

負荷をかけている最中に、別ターミナル(3枚目、または2枚目で ab を回しながら)で top を開きます。

VMの中(Ubuntu Server・別ターミナル)
$ 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 で「スワップしていないか」を確かめる

念のため、メモリとディスクも見ておきます。除外するために見ます。

VMの中(Ubuntu Server・別ターミナル)
$ vmstat 1 5
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 自身に「いま何をしているか」を聞きます。負荷の最中に、別ターミナルで:

VMの中(Ubuntu Server・別ターミナル)
$ sudo mysql bench_cap
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列まとめて張るのがコツです。

VMの中(Ubuntu Server)
$ sudo mysql bench_cap
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万分の1
  • Extra の 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回でも傾向は明らかですが——桁で動かない改善こそ、複数回測って確かめる必要があります。

VMの中(Ubuntu Server・2枚目)
$ ab -n 200 -c 10 "http://127.0.0.1:3000/orders?customer=4242"
$ ab -n 2000 -c 50 "http://127.0.0.1:3000/orders?customer=4242"

[スクリーンショット: 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/s1100 req/s約29倍
p501250 ms38 ms約33分の1
p952100 ms95 ms約22分の1
p992600 ms160 ms約16分の1
EXPLAIN の typeALL(全表走査)ref(索引で一本釣り)—
EXPLAIN の rows49821048約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 を見てください。

VMの中(Ubuntu Server・別ターミナル)
$ 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。上の表なら「一瞬」の域です。トップページの一覧としては、もう十分すぎる——だから止める、という判断ができます。要件は、こうやって体感から先に決めて、測った数字と突き合わせるものです。

「全部を最速にする」という要件は、現実には存在しません。 速くするほどコードは複雑になり、壊れやすくなります。目標の数字を満たしたら、そこで手を止めるのが、正しい設計判断です。

もし本当に次を潰すなら、道はもう見えています(今回はやりませんが、地図として)。

選ぶ順番にも、コツがあります。 安くて副作用の小さいものから試します。

  1. まず、いまの構成のままできること(索引、クエリの書き換え、プロセス数)——お金も新しい部品も要らない
  2. 次に、部品を1つ足すこと(キャッシュ、読み専用の複製)——古い値が返るなどの代償が付くので、要件と相談
  3. 最後に、構成を変えること(非同期化、サービス分割)——効果は大きいが、複雑さも大きい

いきなり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 で、この記事で作ったものだけを消します。

VMの中(Ubuntu Server)
$ sudo 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;

作業フォルダを消します。

VMの中(Ubuntu Server)
$ rm -rf ~/bench-cap

負荷試験ツールは、また使うなら残して構いません。もう使わないなら消せます。

VMの中(Ubuntu Server)
$ sudo apt remove -y apache2-utils

確認します。bench_cap が消えていれば片づけ完了です。

VMの中(Ubuntu Server)
$ sudo mysql -e "SHOW DATABASES;"

本物のアプリでやるときの注意

この「測る → 特定 → 潰す → また測る」の型は、あなたの実際のアプリにもそのまま使えます。 ただし、練習用の 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 50p95 2100ms(記録した)
② 崩れる点を探す-c を 1→100 に振る-c 25 で p95 が跳ねる/天井 38 req/s
③ 1つ特定top / vmstat / EXPLAINmysqld %CPU 188・type=ALL・rows 498210
④ 1つ潰すCREATE INDEX(1本だけ)type=ref・rows 48・1本 0.28→0.002 sec
⑤ また測る同じ abp95 2100 → 95ms/38 → 1100 req/s
⑥ 次を見るtopnode %CPU 99(次のボトルネックへ移動)

システム設計は、図を眺めるものではありませんでした。 自分のサーバーに負荷をかけ、どこが先に音を上げるかを数字で捕まえ、1つだけ直して、また測る。この地味なループが、実践のシステム設計そのものです。図はここから、初めて意味を持ちます。

そして、次に学ぶこと

この記事で潰したのは、たまたま索引の無いクエリ1本でした。 でも、身についたのは索引の知識ではありません。「測る → 1つ特定 → 潰す → また測る」というループです。これは、この先どんな遅さにも効きます。

共通しているのは、この記事でやったこと——「先に測る」——です。 索引でも、プロセス増でも、キャッシュでも、複製でも、非同期でも、測らずに足したものは、効いたかどうか永久に分かりません。 それを、50万行とVM1台で体に入れたのが、このシステム設計深掘りの到達作品でした。


参考リンク


この段階の確認

【深掘り】システム設計 は、ここで終わりです。 次に進む前に、答えを見ずに試してください。

読み終えた直後は、たいてい「分かった気」になっています。 手が動くかどうかは別です。

説明できますか

  1. 設計は図からではなく数から始める。 最初に見積もるものは何か
  2. 99.9% は月に何分の停止か。 その数字で何を決めますか
  3. 台数を増やしたら遅くなったのはなぜか

手が動きますか

  • キャッシュを置く層を選び、なぜそこなのかを説明する
  • 負荷をかけ、ボトルネックが移動することを測る
  • リトライに指数バックオフを入れ、障害を長引かせないようにする

1つでも詰まったら、飛ばした回があります。 そこへ戻ってください。戻るのは後退ではありません。 戻り先の目安: 設計の進め方の回 / キャッシュの層の回 / 可用性とSLOの回

全部答えられたなら、次の段階へ進んでください。


次に読む

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

記事
← 前の記事サービスディスカバリと名前解決 — 相手のIPを書いたら翌日壊れた
→ 次の記事クラウドとは何か・責任共有モデル — 借りても責任は消えない

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

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

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

【深掘り】システム設計の到達作品です。 遅いアプリを負荷試験で測り、ボトルネックを特定して直し、Before/After を数字で示します。

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

コメント

コメントする

目次