設計の進め方と容量見積もり — 図ではなく数から始める

設計と容量見積もり。電卓と利用量の見積書、小さなサーバー模型。

設計は図からではなく数から始めます。利用者数とデータ量から容量を見積もり、いまの限界を測ります。

前回: ボトルネックは動く — 負荷分散とキャッシュの設計

これは【深掘り】の記事です。本線の順路ではありません。 読まなくても先へ進めます。 本線の ボトルネックは動く — 負荷分散とキャッシュの設計 の続きとして、そこで「増やす前に測る」とだけ書いて通り過ぎたところを、「では、設計の話そのものは何から始めるのか」まで戻ってやり直す回です。

この記事のコマンドは、断りがない限りすべてVMの中(Ubuntu Server)で打ちます。 前提: ~/server の Node.js API、nginx、MySQL が動いていること。パフォーマンス改善の回まで終わっている状態を想定しています。 この記事は、システム設計の【深掘り】シリーズの1本目です。 新しいミドルウェアは1つも入れません。入れるのは負荷試験の道具1つだけです。


「このサービスを設計してください」

この一言で固まりました。 何を言えば「設計した」ことになるのか分からなかったからです。

そのとき私がやったのは、紙に四角を描くことでした。四角を並べて「ここにロードバランサ」「ここにキャッシュ」「ここにキュー」と書いていく。それらしい絵にはなりました。 ただ、なぜロードバランサが要るのかを聞かれたら、何も答えられません。

理由ははっきりしています。

一度も数を出していないからです。

1秒に何回叩かれるのかを知らないまま、振り分ける機械を置く理由はありません。 データが1年で何ギガバイトになるのかを知らないまま、データベースを分ける理由もありません。構成図は、数が出たあとに、はじめて描けるものです。

そしてもう1つ、私が勘違いしていたことがあります。

設計とは、正解の構成を当てることだ。

違いました。

設計とは、「何を諦めるかを、先に決めておくこと」です。

速くて、正しくて、安くて、単純なシステムは作れません。どれかを取ると、どれかが落ちます。 設計の話がうまい人は、構成を知っているのではなく、「この場面では、これを諦めます」と言えるだけです。

この記事では、順番を1本通します。 題材は他人のサービスではなく、自分の ~/server です。利用者数から手で数を出して、そのあと実際に負荷をかけて、見積もりと実測を突き合わせます。

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

目次

この記事でわかること

  • 設計は構成図から始めないこと。構成図は5段階のうち4番目で、その前に3つやることがあるということ
  • 「1秒に何回」が分かると、必要なものが自動的に決まること。逆に、それが無いと何を置いても理由が書けないということ
  • 見積もりの目的は当てることではないこと。桁が合っていれば十分で、2倍ずれても判断は変わらないということ
  • 非機能要件は、数字にしないと要件ではないこと。「速く」「落ちないように」は要件ではなく願望だということ
  • 速さ・正しさ・安さ・単純さは同時に満たせないこと。設計とは、そのうちどれを捨てるかを先に決める作業だということ
  • 自分のアプリは、必要量の200倍以上さばけていたこと。測る前に足そうとしていたものは、全部要らなかったということ

この記事でやること

  1. 設計を始める順番(要件 → 数 → 制約 → 構成 → 検証)を、表で固定する
  2. ~/server の tasks を題材に、利用者数から1秒あたりのリクエスト数とピークを、表で計算する
  3. 1件あたりのデータ量を手で見積もり、MySQL の実測値(avg_row_length)と突き合わせる
  4. ab で 1台の限界を req/s で実測し、top・free・ss・vmstat でどこが詰まるかを確かめる
  5. 見積もりと実測を比べて、「足りているのか、足りないのか」を1行で言えるようにする

先に知る言葉

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

言葉意味
キャパシティ見積もり必要な量を、計算で先に出すこと。 利用者数から req/s とデータ量を出す作業
DAU1日に実際に使う人の数(Daily Active Users)。登録者数ではありません
QPS / RPS1秒あたりの問い合わせ数 / リクエスト数。 設計の話で最初に出す数字
ピーク係数平均に対して、忙しい時間帯が何倍になるか。 平均だけで組むと必ず落ちます
機能要件何ができるか。 「タスクを登録できる」「ログインできる」
非機能要件どのくらいの品質でできるか。 速さ・止まらなさ・容量。数字で書くもの
SLO自分で決めた品質の目標値。 「95%のリクエストを300ms以内に返す」のような形
トレードオフ一方を取ると他方が落ちる関係。 設計で決めるのは、たいていこれ
avg_row_lengthMySQL が持っている1行あたりの平均バイト数。見積もりの答え合わせに使えます

レイテンシ(1件が返るまでの時間)とスループット(1秒に何件さばけるか)は、本線の回で出しました。この記事では、その2つを使う側に回ります。

設計を始める順番 — 構成図は4番目

結論から置きます。 私が固まったのは、順番を知らなかったからでした。

段やること出るものここを飛ばすと
① 要件何ができればいいのかを、機能と非機能に分けるやることリストと、数字になった品質目標何を作るか決まっていないのに、作り方の話を始める
② 数利用者数から req/s とデータ量を計算する1秒あたり何回・1年で何GBここが本題。 数が無いと、あとの判断が全部「なんとなく」になる
③ 制約いま使えるもので、どこまでいけるかを測る1台の限界(req/s)と、詰まる場所足りているのに足す。 私がやりかけたこと
④ 構成②と③の差を埋めるものだけを置く構成図ここから始めると、置く理由が書けない
⑤ 検証置いたあと、もう一度測って効いたか確かめる前後の数字効いていないものを、効いたと思い込む

この記事でやるのは ①②③ です。 ④の構成図は、このシリーズの次以降の回で1つずつ扱います。 1本目で構成図を描かないのは、わざとです。 描けるだけの材料が、まだ手元に無いからです。

②と③が揃うと、④は考える必要がほとんど無くなります。 必要が 4 req/s で、1台で 1,000 req/s さばけるなら、置くものはゼロです。必要が 5,000 req/s なら、足りない分だけ増やすことになります。構成は、引き算の答えとして出てきます。

① 要件を2つに分ける

設計の話が噛み合わないとき、たいてい原因はここです。 「速くしたい」と「ログインさせたい」を同じ列に並べて話しているからです。

種類質問の形~/server での例
機能要件何ができるかタスクを登録・一覧・完了できる / ログインできる / 自分のタスクしか見えない
非機能要件どのくらいの品質でできるか何秒以内に返るか / 月にどれだけ止まってよいか / 何件まで持てるか

機能要件は、書けば決まります。 問題は非機能要件のほうです。

非機能要件は、数字にしないと要件ではない

私が最初に書いたものと、書き直したものを並べます。

最初に書いたもの書き直したもの
速く返すピーク時に /api/tasks の 95% を 300ms 以内に返す
落ちないようにする月に止まってよい時間を 43分までとする(99.9%)
たくさん扱えるように同時に 100人、1日 24,000リクエスト、3年で 150万件まで持つ
データを失わないバックアップは1日1回。壊れたときに失ってよいのは、直近24時間分まで

左の列は、要件ではありません。 達成したかどうかを、誰も判定できないからです。 「速く」は、1秒でも速ければ達成です。同時に、0.1秒でも遅ければ未達です。 どちらとも言えるものは、要件として使えません。

止まってよい時間は、%からすぐ出せます。 これは覚えておくと、会話が一気に具体的になります。

稼働率1年で止まってよい時間1か月で感覚
99%約3日15時間約7時間個人開発なら、これで十分なことが多い
99.9%約8時間45分約43分ここから「夜中に起こされる」が始まる
99.99%約52分約4分1人では無理。 自動で切り替わる仕組みが要る

桁が1つ増えるたびに、必要な仕組みも費用も跳ね上がります。 99.99% を目標に置いた瞬間、「人が気づいて直す」は選択肢から消えます。 43分あれば起きて直せますが、4分では無理だからです。 障害対応の回で切り分けの順番を決めたのは、この時間を使い切らないためでした。

まず数を出す — 自分の tasks で計算する

ここが、この記事で一番大事なところです。

架空のサービスではなく、~/server のタスク管理アプリで計算します。 いま動いているのは私1人ぶんですが、「もし 10,000人が使ったら」を紙の上で先に通します。

1. 利用者数から、1秒あたりを出す

上から順に掛けていくだけです。 電卓すら要りません。

段式数置いた根拠
登録者数仮に置く10,000人ここは当て推量で構いません。 桁が合っていればいい
1日に使う人(DAU)10,000 × 20%2,000人登録しても毎日は使わない。2割は多めの見積もり
1人が1日に開く回数—3回朝・昼・夜
1回の表示で飛ぶAPI—4本/api/me /api/tasks /api/stats と、書き込み1本
1日のリクエスト2,000 × 3 × 424,000件
秒あたり(平均)24,000 ÷ 86,400約 0.28 req/s1日は 86,400秒。この数だけは覚える
ピーク(8割が4時間に来る)24,000 × 0.8 ÷ 14,400約 1.3 req/s通勤時間と夜に偏る
瞬間ピーク(安全率3倍)1.3 × 3約 4 req/s通知を送った直後などの跳ね

1万人のサービスで、4 req/s です。

ここで手が止まりました。 「1万人」と聞いて身構えていたのに、出てきた数字が秒4回だったからです。 これが、数を出すことの効果です。 「1万人」は怖い言葉ですが、「秒4回」は怖くありません。 同じことを言っているのに、判断できるのは後者だけです。

押さえるべき数は、この3つだけです。

覚える数値使い道
1日の秒数86,400秒(約 10万秒)1日◯件 ÷ 10万 = 秒あたり。暗算はこれで十分
ピーク係数平均の 3〜10倍平均で組むと、忙しい時間に落ちる
安全率2〜3倍見積もりが外れたときの余白

「1日100万リクエスト」と言われたら、100万 ÷ 10万 = 10、ピークで 3〜10倍だから 30〜100 req/s。 これが即座に出れば、話に付いていけます。 小数点以下は一切要りません。 0.28 も 0.3 も同じ判断になります。桁だけ合っていればいいというのは、そういう意味です。

2. データ量を出す

次は容量です。式は同じ形で、「1件あたり × 件数 × 期間」です。

まず、1件が何バイトかを、列から手で出します。

列型だいたいのバイト数
idINT4
titleVARCHAR(200)約 92(日本語30文字 × 3バイト + 長さ2バイト)
doneBOOLEAN1
created_atTIMESTAMP4
user_idINT4
合計(中身だけ)約 105バイト

これで終わりではありません。 実際には、行のヘッダや索引が付きます。そこは「2〜3倍」で見ます。

段式数
1件あたり(索引込み)105 × 3約 300バイト
1人が1日に作る件数—2件
1日に増える件数2,000人 × 24,000件
1年の件数4,000 × 365約 146万件
1年の容量146万 × 300バイト約 440MB
3年の容量440MB × 3約 1.3GB

3年で 1.3GB です。 いまのVMのディスクに、そのまま入ります。 ここでも判断が変わりました。 数を出す前、私は「データが増えたらデータベースを分ける」という話を、なんとなく前提にしていました。分ける必要が出るのは、この10倍でも先の話です。

3. 手の見積もりを、MySQL に答え合わせさせる

ここまでは紙の上です。実物と合っているか確かめます。

まず、見積もりに近い形のダミーを1万件入れます。

bash
$ sudo mysql
SET SESSION cte_max_recursion_depth = 1000000;

INSERT INTO appdb.tasks (title, done, user_id)
WITH RECURSIVE seq AS (
  SELECT 1 AS n
  UNION ALL
  SELECT n + 1 FROM seq WHERE n < 10000
)
SELECT CONCAT('見積もり用', REPEAT('あ', 25), n), 0, 1 FROM seq;

REPEAT('あ', 25) を入れているのは、わざとです。 ダミー1 のような短い文字列で測ると、1行が実際より小さく出ます。 見積もりの答え合わせをするときは、本番に近い長さのデータで測ってください。 短いダミーで測って「思ったより小さい」と喜ぶのは、自分で自分を騙しているだけです。

入ったら、MySQL に1行あたりのサイズを聞きます。

ANALYZE TABLE appdb.tasks;

SELECT table_rows, avg_row_length, data_length, index_length
FROM information_schema.TABLES
WHERE table_schema = 'appdb' AND table_name = 'tasks';
+------------+----------------+-------------+--------------+
| table_rows | avg_row_length | data_length | index_length |
+------------+----------------+-------------+--------------+
|       9821 |            156 |     1540096 |            0 |
+------------+----------------+-------------+--------------+

読み方です。

列意味どう使うか
table_rows行数。推定値です正確な件数ではありません。 COUNT(*) と数十件ずれます
avg_row_length1行あたりの平均バイト数手の見積もりと突き合わせる主役
data_length中身が使っているバイト数ディスク容量の話に使う
index_length索引が使っているバイト数索引を張ると、ここが増えます

手で出した 300バイトに対して、実測は 156バイトでした。

半分でした。つまり、私の見積もりは「2倍ほど多めに見た」ということになります。 これは失敗ではありません。 多めに外れるのは、設計の見積もりとしては正しい方向です。少なく見積もって足りなくなるより、多く見積もって余るほうが安全だからです。 そして、判断は何も変わりません。 3年で 1.3GB か 700MB かの違いで、やることが変わる場面はありません。 これが「桁が合っていればいい」の実例です。

[スクリーンショット: 01_avg_row_lengthの実測.png] information_schema.TABLES の結果で、avg_row_length と data_length の値が読める状態を撮ってください。数字は環境で違って構いません。

いまの限界を測る — 足りているのか

必要な数(4 req/s)が出ました。次は、いま何 req/s さばけるかです。

この2つが揃うまで、何を足すかは決められません。

道具を入れる

ab(Apache Bench)を使います。 本線の回と同じものです。すでに入っていれば飛ばしてください。

bash
$ sudo apt update
$ sudo apt install -y apache2-utils
$ ab -V
This is ApacheBench, Version 2.3 <$Revision: 1903618 $>

apache2-utils であって apache2 ではありません。 Webサーバーの Apache は入りません(入れると80番を nginx と取り合って事故ります)。 hey でも構いません。 Go製で、ab より新しく、出力が読みやすいです。ただし Ubuntu の標準リポジトリには無く、配布物を自分で置く必要があります。この記事は、準備が一番少ない ab で通します。

負荷試験は、自分のVMにだけ向けてください。 大量のリクエストを機械的に送る道具なので、向ける先を間違えると、やっていることは攻撃と区別が付きません。 今回の宛先は localhost だけです。VMware の仮想マシンは自分のPCの中に閉じているので、外に一切迷惑がかかりません。

測る

ログインが要るので、まず Cookie を取ります。

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

$ SID=$(awk '/connect.sid/{print $7}' cookie.txt)
$ echo "${SID:0:20}..."
s%3AkL3v9xQ2mB7...

全部は表示していません。 これはそのまま他人になりすませる文字列です。認証の回で書いたとおり、画面に出したり貼ったりしないでください。

bash
$ ab -n 2000 -c 20 -k -C "connect.sid=$SID" http://localhost/api/tasks
Concurrency Level:      20
Time taken for tests:   1.812 seconds
Complete requests:      2000
Failed requests:        0
Non-2xx responses:      0
Requests per second:    1103.75 [#/sec] (mean)
Time per request:       18.120 [ms] (mean)

Percentage of the requests served within a certain time (ms)
  50%     17
  95%     28
  99%     41
 100%     63 (longest request)

Failed requests と Non-2xx responses を、req/s より先に見てください。 ここが 0 でないと、他の数字に意味がありません。401 を高速に返しているだけを性能だと思い込むのは、実際にやった事故です(後述)。

[スクリーンショット: 02_abの結果.png] ab の結果で、Failed requests: 0 と Requests per second の行が両方読める状態を撮ってください。

見積もりと突き合わせる

この記事の答え合わせです。

見るもの数出どころ
必要(瞬間ピーク)約 4 req/s山場①の計算
実測(1台)約 1,100 req/sいまの ab
余裕約 275倍割っただけ
非機能要件(95%を300ms以内)実測 28ms満たしている
3年後の容量約 700MB〜1.3GBディスクに入る

ここが、この記事の結論です。

1万人が使っても、いまの1台で足ります。 足りないどころか、275倍余っています。

つまり、私が構成図に描き込もうとしていたロードバランサもキャッシュもキューも、1つも要りませんでした。 要らないと言えるようになったのは、絵をきれいにしたからではなく、割り算を2回したからです。

これは「何も学ばなくていい」という話ではありません。 逆です。

必要になる条件が、はじめて数字で言えるようになりました。 /api/tasks が 1,100 req/s なので、瞬間ピークが 1,100 を超える見込みが出たら手を打つ。 安全率を見て、300 req/s を超えたら準備を始める。 これが「いつやるか」の答えです。 「そのうち」でも「アクセスが増えたら」でもありません。

どこが詰まるのかを、4か所で確かめる

「1,100 で頭打ち」を決めているのは誰かを見ます。候補は4つだけです。

片方のターミナルで、長めに流し続けます。

bash
$ ab -n 20000 -c 20 -k -C "connect.sid=$SID" http://localhost/api/tasks

もう片方で、順番に見ます。

bash
$ nproc
$ top -b -n 1 | head -12
2
top - 15:04:22 up  2:11,  2 users,  load average: 1.42, 0.71, 0.35
%Cpu(s): 52.1 us,  9.4 sy,  0.0 ni, 36.2 id,  0.3 wa
    PID USER      PR  NI    VIRT    RES  %CPU %MEM     TIME+ COMMAND
   1188 ubuntu    20   0  712344  78120  99.3  2.4   0:41.22 node
    912 www-data  20   0   58204  12440  11.7  0.4   0:05.90 nginx
bash
$ free -h
               total        used        free      shared  buff/cache   available
Mem:           3.8Gi       912Mi       1.7Gi       1.0Mi       1.2Gi       2.7Gi
Swap:             0B          0B          0B
bash
$ ss -s
$ sudo mysql -e "SHOW STATUS LIKE 'Threads_connected'; SHOW VARIABLES LIKE 'max_connections';"
Total: 214
TCP:   187 (estab 43, closed 121, orphaned 0, timewait 121)

+-------------------+-------+
| Variable_name     | Value |
+-------------------+-------+
| Threads_connected | 11    |
+-------------------+-------+
+-----------------+-------+
| Variable_name   | Value |
+-----------------+-------+
| max_connections | 151   |
+-----------------+-------+
bash
$ 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
 3  0      0 1782340  98244 1204112    0    0     0    12 4821 9134 53 10 37  0  0
 2  0      0 1782080  98244 1204112    0    0     0     0 4903 9288 55  9 36  0  0

4つを、見る場所と判定でまとめます。

詰まる候補見るもの判定今回の結果
CPUtop の %Cpu(s) と、プロセスごとの %CPUid(暇)が減っている / 1プロセスが 100 に張り付くnode が 99.3%。1コアを使い切っている
メモリfree -h の available と Swapavailable が減り続ける / Swap が動く2.7Gi 空き、Swap ゼロ。余裕
DB接続Threads_connected と max_connections上限に近づく11 / 151。余裕
ディスクvmstat の wa(I/O待ち)wa が数%以上ある0。まったく待っていない

犯人は CPU、それも「1プロセスしか動いていないこと」でした。 nproc は 2 なのに、%Cpu(s) の id が 36% 残っています。 CPUは2本あるのに、1本しか使えていないということです。 Node.js は1プロセスで1つのことしかしません。 サーバーとは何かの回で書いた「待ち続けるプログラム」が、1個しかいないからです。

[スクリーンショット: 03_topとvmstatで詰まりを見る.png] nproc の出力、top で node の %CPU が100付近、vmstat の wa が0の状態が読めるように撮ってください。

この事実の使い道は、いまはありません。 必要が 4 req/s なので、直す理由が無いからです。 「直せると分かったが、直さない」は、正しい設計の結論です。 パフォーマンスの回で書いた「直さないという判断」と、同じことをしています。

決められないことを決める — トレードオフ

数が出て、限界も分かりました。それでも設計には、計算で決まらない部分が残ります。

残るのは、この4つの取り合いです。

欲しいもの具体的には取ると、何が落ちるか
速さ返るのが速い / たくさんさばける正しさ(古いデータを返す)、安さ(台数が要る)
正しさいつ読んでも最新 / 二重に処理しない速さ(毎回データベースに行く)、単純さ(確認の仕組みが増える)
安さサーバー代が少ない速さ(1台に詰め込む)、止まらなさ(予備が無い)
単純さ部品が少なく、壊れたときに追える速さ(工夫を入れられない)、柔軟さ

具体例で見ると、はっきりします。

打ち手取るもの落ちるもの
結果をキャッシュする速さ正しさ。 更新しても、しばらく古い値が返る
データベースを複製して読み分ける速さ・止まらなさ正しさ。 書いた直後に読むと、まだ無い(レプリケーションの回)
重い処理を後回しにする応答の速さ単純さ。 失敗したときの追跡が増える
1台に全部入れる安さ・単純さ止まらなさ。 その1台が落ちたら全部止まる
何も足さない単純さ・安さ速さ。 ただし今回は、それで足りている

この表に「正解」の列はありません。 場面ごとに、どれを捨てるかが変わるだけです。 設計の会話が成立するかどうかは、ここで決まります。 「キャッシュを入れます」だけでは足りず、「速さを取って、最大10秒ぶん古いデータを許します」まで言えて、はじめて判断できる形になります。

そして、捨てるものは非機能要件で決まります。

非機能要件に書いたこと自動的に捨てられるもの
月に43分まで止まってよい「常に最新」を守り切ること(切り替え中は多少の遅れが出る)
95%を300ms以内残り5%。全件を速くすることは目標にしていない
個人開発なので費用は月1,000円まで冗長化。予備の1台は、この予算に入らない

①で書いた非機能要件が、ここで効きます。 数字にしていないと、何を捨ててよいかが決まりません。 「速く、落ちず、安く」と書いてしまうと、全部を守ろうとして、何も決まらなくなります。

概算の単位を覚える — 桁だけ

設計の会話で、もう1つ必要なものがあります。「その処理は何秒かかるか」の感覚です。

正確な値は要りません。桁だけ覚えます。

動作だいたい1つ上との比
CPUの中のキャッシュを見る1 ナノ秒(ns)—
メモリを1回読む100 ns(0.1 マイクロ秒)100倍
SSDから1回読む100 マイクロ秒(μs)1,000倍
同じ機械の中で通信する100 μs 前後同じくらい
HDDのヘッドを動かす10 ミリ秒(ms)100倍
同じデータセンターの中を1往復0.5 ms—
東京から大阪を1往復10 ms20倍
東京からアメリカ西海岸を1往復100 ms10倍

覚え方は、4語だけです。

メモリはナノ秒。SSDはマイクロ秒。国内のネットワークはミリ秒。海外は100ミリ秒。 1つ下がるごとに、だいたい1,000倍です。

これが分かると、次のような判断が即座に付きます。

場面桁から出る答え
メモリのキャッシュに置くか、SSDに置くか1,000倍違う。 何度も読むものなら、迷わずメモリ
海外のAPIを1リクエスト中に3回呼ぶ100ms × 3 = 300ms。これだけで非機能要件を割る
SQLを1本 12ms、外部APIを1本 240msSQLをどれだけ磨いても、体感は変わらない(パフォーマンスの回で実際に見ました)
サーバーを海外に置くか国内に置くか往復で 100ms 差。 利用者が国内なら、置き場所だけで負ける

数字を暗記する必要はありません。 必要なのは、「これはナノ秒の話か、ミリ秒の話か」を間違えないことだけです。 ミリ秒の作業をナノ秒の道具で速くしようとするのが、一番よくある無駄です。

このシリーズで何をやるか

【深掘り】システム設計 は、全17本(学習16回+到達作品1本)の予定です。

このシリーズの方針を、1本目のうちに書いておきます。

言葉を覚える回にはしません。 毎回、手元のVMで動かして、数字を出します。 「ロードバランサとは」で終わる回は作りません。 入れる前と入れたあとの数字を、必ず両方出します。 効かなかったときは、効かなかったと書きます。

  1. 設計の話の始め方(この記事) — 要件 → 数 → 制約 → 構成 → 検証。容量を見積もる
  2. レイテンシとスループット — 「速い」を2つの数字に分け、片方だけ良くなる場面を作る
  3. ロードバランサと振り分け方式 — 振り分け方を並べて比べ、偏るところまで見る
  4. キャッシュを置く5つの層 — ブラウザ・CDN・アプリ・DB、どこに置くと何が効くか
  5. キャッシュの更新戦略 — 古いデータをいつ捨てるか。捨て損ねると何が起きるか
  6. CDNとエッジキャッシュ — 距離を縮める仕組みと、縮まらないもの
  7. 非同期処理とジョブキュー — 待たせない代わりに、何が難しくなるか
  8. メッセージキューの型 — 1回だけ処理する、を成立させる
  9. 結果整合性とCAP定理 — 「いつ読んでも最新」を捨てるとはどういうことか
  10. 可用性とSLO — 99.9%が守られているかを、どう見張るか
  11. 指数バックオフとバルクヘッド — 二重到達・障害の連鎖を前提に組む
  12. レプリケーションとシャーディング — 読み書きを分ける、それでも足りないとき
  13. データストアの選び方 — RDB以外も含め、測って選ぶ
  14. イベント駆動アーキテクチャ — 機能を足しても既存が壊れない繋ぎ方
  15. 遅いアプリのアンチパターン7つ — 実際に踏んで、測って直す
  16. サービスディスカバリと名前解決 — 相手のIPを直書きしない仕組み
  17. 到達作品:遅いアプリを測って直す — シリーズの集大成(新しい知識は足さない)

リンクはまだ張っていません。 書けた回から順に、ナビが繋がります。 この深掘りシリーズ全体が、本線の脇道です。 飛ばしても本線は進みます。

つまずいたところ

構成図を先に描いて、30分ぶん捨てた

最初にやったのは、四角と矢印を並べることでした。 ロードバランサ、キャッシュ、キュー、レプリカ。それらしい絵が完成しました。

そのあと数を出したら、必要なのは 4 req/s でした。 実測は 1,100 req/s。描いた四角は、1つも置く理由がありませんでした。

順番を守れば、この30分は要りませんでした。 絵は、手が動いている感じがするので危険です。 何も判断していないのに、進んだ気になります。割り算を2回するほうが、絵よりずっと速く結論に着きます。

Failed requests を見ずに「速い」と言った

最初の ab で 3,000 req/s という数字が出て、喜びました。

-C を付け忘れていて、全部 401 が返っていただけでした。Non-2xx responses に 2000 と書いてありましたが、Requests per second の行しか読んでいませんでした。

エラーを返すのは、正常に処理するより速いです。 失敗が多いほど、req/s は上がります。 負荷試験の結果は、上から順に読んでください。 Failed requests → Non-2xx responses → Requests per second → パーセンタイル。この順番以外で読むと、必ず騙されます。

table_rows を本当の件数だと思った

information_schema の table_rows が 9,821 と出て、「1万件入れたのに179件足りない」と焦りました。

SELECT COUNT(*) FROM appdb.tasks;

こちらは 10,003 件で、正しく入っていました。

table_rows は推定値です。 InnoDB では、統計情報から見積もった数が返ります。数%はずれます。 正確な件数が要るときは COUNT(*)、傾向を見るだけなら table_rows。 ANALYZE TABLE を打つと、推定値は多少マシになります。

短いダミーで測って、見積もりが合ったと思った

最初は CONCAT('ダミー', n) で入れました。 avg_row_length は 48 でした。

手の見積もりは 300バイトだったので、「6倍も外した」と落ち込みました。 原因は単純で、ダミー1 は日本語3文字で9バイトしかないからです。本番のタスク名が9バイトということはありません。

見積もりの答え合わせは、本番に近いデータでやってください。 測る対象がおかしいと、測定は「合っている風の嘘」を返します。 これは負荷試験でもまったく同じで、空のテーブルに対する ab の数字は、本番の参考になりません。

後片づけ

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

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
$ sudo mysql -e "SELECT table_name, data_length FROM information_schema.TABLES WHERE table_schema='appdb' AND table_name='tasks';"

data_length が減っていなくても、壊れていません。 InnoDB は、消した場所を「空き」として持ったままで、次に入れるときに再利用します。 本当に縮めたいときは OPTIMIZE TABLE appdb.tasks; ですが、実行中は表がロックされます。 練習環境なら構いませんが、動いているサービスで軽い気持ちで打たないでください。

Cookie のファイルを消します。

bash
$ cd ~/server
$ rm -f cookie.txt

これは、そのまま他人になりすませる文字列が入ったファイルです。残しっぱなしにしないのが習慣です。

残すもの。

  • ab(apache2-utils) …… 入れたままで構いません。 ディスクを数MBしか使わず、このシリーズで毎回使います
  • 山場①の計算の表 …… メモに残してください。 次以降の回で、この 4 req/s と 1,100 req/s を何度も参照します

元に戻っているか確認します。

bash
$ systemctl is-active nginx
$ systemctl is-active mysql
$ curl -o /dev/null -s -w "%{http_code}\n" http://localhost/api/tasks
active
active
401

401 で正解です。 Cookie を消したので、ログインしていない状態として弾かれています。サーバーは動いています。

まとめ

  • 「設計してください」で固まったのは、順番を知らなかったから。 要件 → 数 → 制約 → 構成 → 検証の5段で、構成図は4番目
  • 構成図から描き始めると外す。 描いた四角に、置く理由を書けない。割り算2回のほうが、絵より速く結論に着く
  • 要件は機能と非機能に分ける。 非機能は数字にしないと要件ではない。「速く」「落ちないように」は、達成を誰も判定できない
  • 止まってよい時間は%から出る。 99%で月7時間、99.9%で月43分、99.99%で月4分。 4分になると「人が起きて直す」が選択肢から消える
  • 数は、掛け算を上から並べるだけで出る。 1万人 → DAU 2,000人 → 1日24,000リクエスト → 秒あたり 0.28 → ピーク 4 req/s
  • 覚える数は3つだけ。 1日は86,400秒(約10万秒)、ピーク係数3〜10倍、安全率2〜3倍
  • 「1万人」は怖いが「秒4回」は怖くない。 同じことを言っているのに、判断できるのは後者だけ
  • データ量は「1件 × 件数 × 期間」。 tasks は手で300バイト、実測 156バイト。3年で1.3GBにもならない
  • 2倍外れても判断は変わらない。 桁が合っていれば見積もりは成功。小数点以下は1つも要らない
  • 見積もりの答え合わせは、本番に近いデータで。 短いダミーで測ると、合っている風の嘘が返る
  • ab の実測は 1,100 req/s。 必要 4 req/s に対して 275倍余っていた
  • 描こうとしていたロードバランサもキャッシュもキューも、1つも要らなかった。 要らないと数字で言えるようになったのが成果
  • 代わりに「いつ必要か」が出た。 瞬間ピークが300 req/sを超えたら準備を始める。 「そのうち」ではなくなった
  • 詰まる場所の候補は4つ。 CPU(top)/ メモリ(free)/ DB接続(Threads_connected)/ ディスク(vmstat の wa)
  • 今回の犯人はCPU、それも「1プロセスしかいないこと」。 CPUは2本あるのに1本しか使えていない。ただし直す理由が無いので直さない
  • 速さ・正しさ・安さ・単純さは同時に満たせない。 何を捨てるかは、非機能要件に書いた数字が決める
  • 打ち手は必ず何かを落とす。 キャッシュは正しさを、レプリカは「書いた直後に読める」を、非同期は単純さを落とす
  • 概算は桁だけ覚える。 メモリはns、SSDはμs、国内ネットワークはms、海外は100ms。1段ごとに約1,000倍
  • ミリ秒の問題を、ナノ秒の道具で直そうとしない。 海外APIを3回呼べば、それだけで300ms

参考リンク


次に読む

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

記事
← 前の記事自前運用かマネージドか — 放っておくと1年で止まる
→ 次の記事レイテンシとスループット — 台数を増やしたら遅くなった

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

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

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

System Design›System Design — 進め方
  • 設計は図ではなく数から始める
  • 要件→数→制約→構成→検証の順番

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

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

コメント

コメントする

目次