スケールとアムダールの法則 — 状態を持つと台を増やせない

スケールとアムダールの法則。複数のワーカー装置と共通の処理ゲート、共有状態の箱。

※本記事はアフィリエイト広告(PR)を含みます。

状態を持つと、台数を増やしても速くなりません。アムダールの法則で、増やせる限界を数字で確かめます。

前回: 公開鍵暗号とTLS — 鍵は渡さずに秘密を共有する

これは【深掘り】の記事です。本線の順路ではありません。 そして、このコンピュータ科学 深掘りシリーズの、解説としては最後の回です(このあとに到達作品が1本あります)。24回かけて、数え方・データ構造・探索・並列まで手で書いてきました。 最後は「それを何台のマシンに載せるか」の話です。飛ばしても本線は進めます。 本線側の負荷分散とキャッシュの設計は ボトルネックは動く — 負荷分散とキャッシュの設計 にあります。

この記事のコマンドは、VMの中(Ubuntu Server)で打ちます。 Windows の PowerShell ではありません。VM の立て方は VMを29台溜めた話 — Ubuntu Serverの立て方 にあります。

この記事の実験は、VMのCPUコアが多いほうがはっきり出ます。 ワーカーを8個まで増やすので、 できれば8コアにしてから読み進めてください。 少なくとも4コアは要ります。確認は ② でやります。


「遅いならサーバーを増やせばいい」と思っていました。

作ったAPIが重くなってきたとき、私が最初に考えたのは「もう1台立てて振り分ければ2倍捌けるだろう」でした。 実際に2台立てて、前に振り分ける役を置きました。動きました。

そして、ログインが通らなくなりました。

ログインボタンを押すと「ログインしました」と出ます。次の画面に進むと「ログインしてください」に戻ります。 もう一度押すと通ります。次でまた戻ります。交互に、規則正しく壊れていました。

Cookie は送られていました。サーバーのコードも変えていません。1台のときは完全に動いていました。 増やした瞬間に壊れた。 これが理解できませんでした。

セッションを、サーバーが自分のメモリに持っていました。 ログインを受け付けたのは1号機で、次のリクエストを受けたのは2号機。 2号機は、そのセッションを見たことがありません。

もうひとつ、同じころに勘違いしていたことがあります。

「4台にすれば4倍速くなる」と思っていました。 なりません。 並列にできない部分が全体の5%あるだけで、台数を無限に増やしても上限は20倍です。

この記事では、この2つを式と実測の両方で確かめます。そのうえで、リバースプロキシとCDNが 「どの仕事を誰に肩代わりさせているか」を、自分で立てて、自分のサイトの実測値で見ます。

最後に、roadmap.sh にある「言語を1つ選ぶ」という項目について、このサイトの答えを正直に書きます。

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

目次

この記事でわかること

  • 垂直(1台を強くする)には上限があり、水平(台数を増やす)には上限が無い。 でも垂直のほうが圧倒的に簡単で、個人開発はたいていそこで終わる
  • アムダールの法則。並列にできない部分が全体の速度を決める。 95%並列化できても、上限は20倍
  • 実測すると、理論値にすら届かない。 8ワーカーで理論6.12倍のところ、実測4.53倍だった
  • 状態を自分のメモリに持つと、台を増やした瞬間に壊れる。 「ステートレスにする」は水平スケールの前提条件であって、おまけではない
  • フォワードプロキシとリバースプロキシは、名前が似ているだけでまったく別のもの。 立つ場所が逆
  • CDNは「距離」と「同じものを何度も返す仕事」を外に出す仕組み。 このサイトの実測では、転送量の75%が静的ファイルだった
  • ボトルネックは1つしかない。 ディスクで詰まっているときにCPUを増やしても、実測で1.49倍で頭打ちのまま動かない
  • 最初の言語は何でもよい。 2つ目を学んだときに、初めて「言語の地図」ができる

この記事でやること

  1. 垂直と水平を表で対比する(上限・停止が要るか・コスト曲線・複雑さ)
  2. アムダールの法則を式で出し、並列化率 50% / 90% / 95% / 99% の上限を計算して表にする
  3. JavaScript で「一部だけ並列にできる処理」を書き、ワーカー数1〜8で実測して頭打ちを確認する
  4. メモリにセッションを持つサーバーを2台立て、ログイン状態が消えるところを再現し、外に出して直す
  5. リバースプロキシを立て、バックエンドのポートが外から見えなくなることを確かめる
  6. 自分のサイトの静的ファイルとHTMLの転送量を実測し、比率を出す
  7. ディスクで詰まらせた状態でワーカーを増やし、速くならないことを実測する
  8. 最初の言語の選び方を表にして、このシリーズ24回を振り返る

先に知る言葉

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

言葉意味
垂直スケール(スケールアップ)1台のマシンを強くすること。CPU・メモリ・ディスクを足す
水平スケール(スケールアウト)マシンの台数を増やすこと。前に振り分ける役が要る
アムダールの法則並列にできない部分が、全体の速度の上限を決めるという式
グスタフソンの法則問題のほうを大きくするなら、上限の話は変わるという見方
ステートレスサーバーがリクエストをまたいで自分で覚えていない状態。水平スケールの前提
セッション「この人はログイン済み」というサーバー側の覚え書き。Cookie の中身ではない
ラウンドロビン振り分け方のひとつ。順番に1台ずつ回すだけ
フォワードプロキシクライアント側に立つ代理。社内から外に出るときに通す
リバースプロキシサーバー側に立つ代理。外から来た人が最初に当たる
CDN世界中に置いたコピー置き場。近い場所から返して距離を消す
ボトルネック全体の速さを決めているいちばん詰まっている1箇所
TLS終端暗号化を手前で解いて、後ろには素のHTTPで渡すこと

① 垂直と水平 — 上限があるほうが、たいてい正解

まず言葉を固定します。

  • 垂直スケール= 1台を強くする。 コアを4から8に、メモリを4GBから16GBに
  • 水平スケール= 台数を増やす。 1台を2台に、2台を10台に

図にすると、増える方向が違うだけです。

垂直(上に伸ばす)              水平(横に並べる)

  ┌──────────┐                  ┌────┐ ┌────┐ ┌────┐
  │  8コア   │                  │2コア│ │2コア│ │2コア│
  │  32GB    │                  │4GB │ │4GB │ │4GB │
  │          │                  └────┘ └────┘ └────┘
  └──────────┘                       ↑ 前に振り分ける役が要る

対比表

垂直(1台を強くする)水平(台数を増やす)
上限ある。 売っている一番大きいマシンで終わり無い。 理屈のうえでは何台でも
停止が要るかたいてい要る。 物理マシンなら電源を落とす。クラウドでも再起動要らない。 動かしたまま足せる
コスト曲線急に上がる。 性能2倍のマシンは値段2倍では買えないほぼ直線。 同じマシンを買い足すだけ
アプリの変更要らないことが多い。 コードはそのまま要る。 ステートレスにしないと壊れる(③ でやります)
障害のときその1台が落ちたら全部止まる1台落ちても残りで受けられる
運用の複雑さ低い。 見る場所が1つ高い。 ログが散る・設定が散る・同期の問題が出る
効き方すぐ効く。 買った瞬間に速い効かないこともある。 ②③ の条件を満たしていないと

ここが一番大事な事実です。 垂直には上限があり、水平には上限が無い。しかし垂直のほうが圧倒的に簡単で、たいていの個人開発はそこで終わります。

「上限が無い」ほうが優れているように見えます。でも上限に当たるまで使い切っている個人開発は、ほぼありません。 メモリを4GBから16GBにするだけで解決する問題に、2台目とロードバランサとセッション共有を持ち込むのは、負けです。 増えるのは性能ではなく、壊れる場所の数です。

判断の順番はこうです。

  1. 測る。 どこが詰まっているか特定する(⑦ でやります)
  2. 直す。 コードやSQLで直せるなら、それが一番安い
  3. 垂直。 1台を強くして届くなら、それで終わり
  4. 水平。 上の3つで届かないときだけ

私は最初、1をすっ飛ばして4をやりました。 その結果が、この記事の冒頭のログイン事故です。


垂直スケールを小さな単位で試すなら、プランが段階的に用意されたVPSが向いています。シンVPSの大容量メモリプランは1GB(1コア)・2GB(2コア)・4GB(3コア)と段階があり、1GBは1ヶ月契約750円〜36ヶ月契約で月451円(2026-11時点、税込)です。無料のお試し期間は無く最低利用期間が3ヶ月で、安い月額は36ヶ月契約の価格なので、契約期間は用途に合わせて選んでください。

② アムダールの法則

「4台にすれば4倍」がなぜ成り立たないかを、式から出します。

準備 — 作業場所を作る

bash
$ mkdir -p ~/cslab/scale
$ cd ~/cslab/scale

コア数を確認します。

bash
$ nproc
8

4より小さい場合は、VMware の設定でコアを増やしてから続けてください。 1コアだと、この実験はそもそも成立しません。

式

処理全体のうち、並列にできる割合を p とします(残りの 1 - p は、どうやっても1本でしか走らない部分)。 台数(ワーカー数)を n とすると、速度の倍率はこうなります。

             1
速度倍率 = ─────────────
           (1 - p) + p/n

n を無限に大きくすると、p/n は 0 に近づきます。 残るのは (1 - p) だけ。つまり、

             1
上限 = ───────────
          1 - p

上限は、台数ではなく「並列にできない部分の割合」だけで決まります。

計算してみる

p を変えて、実際に数を出します。

bash
$ node -e "
  for (const p of [0.5, 0.9, 0.95, 0.99]) {
    const row = [2, 4, 8, 16, 64].map(n => (1 / ((1 - p) + p / n)).toFixed(2));
    console.log((p*100)+'%', row.join('\t'), '上限', (1/(1-p)).toFixed(1));
  }"
50% 1.33	1.60	1.78	1.88	1.97 上限 2.0
90% 1.82	3.08	4.71	6.40	8.77 上限 10.0
95% 1.90	3.48	5.93	9.14	15.42 上限 20.0
99% 1.98	3.88	7.48	13.91	39.26 上限 100.0

表にします。

並列にできる割合2台4台8台16台64台∞台でも
50%1.33倍1.60倍1.78倍1.88倍1.97倍2倍まで
90%1.82倍3.08倍4.71倍6.40倍8.77倍10倍まで
95%1.90倍3.48倍5.93倍9.14倍15.42倍20倍まで
99%1.98倍3.88倍7.48倍13.91倍39.26倍100倍まで

読み方が3つあります。

  1. 95%並列化できても、上限は20倍。 「ほとんど並列にできている」つもりでも、そこで止まります
  2. 90%と99%で、上限が10倍違う。 差は「残りの1割か1分か」だけ。直列部分を削るほうが、台数を増やすより効く
  3. 64台にしたときの効率を見る。 95%のとき 15.42倍 ÷ 64台 = 1台あたり24%しか働いていません

だから「並列にできない部分」を探すのが先です。 起動処理、設定の読み込み、最後の集計、DBへの1本の書き込み。ここが 1 - p です。

グスタフソンの法則 — 前提が違えば結論も違う

アムダールの法則は「仕事の量を固定して、速く終わらせる」話です。 これに対してグスタフソンの法則は、「台数が増えたなら、もっと大きい問題を解けばいい」という見方をします。

現実には、台数を増やす理由は「同じ処理を速く」ではなく「もっと多くのユーザーを捌く」であることが多い。 その場合、直列部分の割合は問題を大きくしても増えないので、頭打ちの形が変わります。

この記事で扱うのはアムダールのほうです。 「1つの処理を速くしたい」ときは、必ずアムダールに当たるからです。 グスタフソンが効くのは「捌く量を増やしたい」ときで、それは水平スケールの本来の目的でもあります。


③ 実測 — 理論どおり頭打ちになるか

式が正しくても、現実はさらに悪いはずです。ワーカーの起動、データの受け渡し、メモリの取り合い。 実際に測ります。

「一部だけ並列にできる処理」を書く

amdahl.mjs を作ります。

bash
$ nano ~/cslab/scale/amdahl.mjs
import { Worker, isMainThread, parentPort, workerData } from 'node:worker_threads';

// 1単位ぶんのCPU仕事。中身は何でもよい(最適化で消えないように結果を返す)
function burn(units) {
  let x = 0;
  for (let i = 0; i < units * 2_000_000; i++) x = (x + Math.sqrt(i % 1000)) % 100000;
  return x;
}

if (!isMainThread) {
  parentPort.postMessage(burn(workerData));
} else {
  const TOTAL  = 200;   // 並列にできる部分の仕事量
  const SERIAL = 10;    // ⚠️ 並列にできない部分(全体の約5%)
  const t = () => Number(process.hrtime.bigint()) / 1e6;

  async function run(n) {
    const t0 = t();
    burn(SERIAL);                        // ここは何台あっても1本でしか走らない
    const each = TOTAL / n;              // 残りを n 個に割る
    await Promise.all([...Array(n)].map(() => new Promise((res, rej) => {
      const w = new Worker(new URL(import.meta.url), { workerData: each });
      w.on('message', () => {}); w.on('error', rej); w.on('exit', res);
    })));
    return t() - t0;
  }

  const base = await run(1);
  console.log('ワーカー数\t実測(ms)\t実測の速度倍率');
  console.log(`1\t\t${base.toFixed(0)}\t\t1.00`);
  for (const n of [2, 3, 4, 5, 6, 7, 8]) {
    const ms = await run(n);
    console.log(`${n}\t\t${ms.toFixed(0)}\t\t${(base / ms).toFixed(2)}`);
  }
}

やっていることは単純です。 毎回まず burn(10) を1本で走らせ(=直列部分)、 そのあと burn(200) ぶんを n 個のワーカーに割ります。

まず、直列部分の割合を測る

理論値と比べるには、p の実際の値が要ります。

bash
$ cat > ~/cslab/scale/serialpart.mjs <<'EOF'
  function burn(units){let x=0;for(let i=0;i<units*2_000_000;i++)x=(x+Math.sqrt(i%1000))%100000;return x;}
  const t=()=>Number(process.hrtime.bigint())/1e6;
  let a=t(); burn(10);  const s=t()-a;
  a=t();     burn(200); const p=t()-a;
  console.log('直列部分(10単位):', s.toFixed(0),'ms');
  console.log('並列にできる部分(200単位):', p.toFixed(0),'ms');
  console.log('合計:', (s+p).toFixed(0),'ms  並列化できる割合 p =', (p/(s+p)*100).toFixed(1)+'%');
  console.log('理論上限(1/(1-p)) =', (1/(1-p/(s+p))).toFixed(1)+'倍');
  EOF
$ node ~/cslab/scale/serialpart.mjs
直列部分(10単位): 286 ms
並列にできる部分(200単位): 6246 ms
合計: 6532 ms  並列化できる割合 p = 95.6%
理論上限(1/(1-p)) = 22.8倍

この処理は 95.6% が並列化できます。台数を無限に増やしても、22.8倍が上限です。

走らせる

bash
$ node ~/cslab/scale/amdahl.mjs
ワーカー数	実測(ms)	実測の速度倍率
1		5782		1.00
2		3474		1.66
3		2299		2.52
4		1956		2.96
5		1646		3.51
6		1565		3.69
7		1355		4.27
8		1277		4.53

理論値と並べます。

ワーカー数実測(ms)実測の倍率理論値(p=95.6%)差
157821.001.00—
234741.661.92−0.26
322992.522.76−0.24
419562.963.53−0.57
516463.514.25−0.74
615653.694.92−1.23
713554.275.54−1.27
812774.536.12−1.59

読み取れることが3つあります。

  1. 8ワーカーで 4.53倍。8倍にはまったく届いていません
  2. 理論値にも届いていません。 理論6.12倍に対して実測4.53倍。しかも差は台数が増えるほど広がっています
  3. 6→7→8 の伸びを見てください。 3.69 → 4.27 → 4.53。1台増やして得られる分が、どんどん減っています

3つ目が一番効きます。7台目で +0.58倍、8台目で +0.26倍。 この調子だと、 9台目、10台目に払うお金は、ほとんど何も買っていません。

理論値に届かない理由は、アムダールの式に入っていない費用があるからです。

  • ワーカーの起動コスト(1個あたり数十ms。8個なら無視できない)
  • メモリ帯域の取り合い(8個が同時に配列を舐めると、CPUはメモリ待ちになる)
  • 待ち合わせ(一番遅いワーカーが終わるまで、全員終われない)

アムダールの法則は「これ以上は速くならない」上限であって、「ここまでは速くなる」保証ではありません。

📸 スクリーンショット1: node ~/cslab/scale/amdahl.mjs の出力全体。 ワーカー数が6→7→8と増えても、倍率がほとんど伸びていないところが残るように撮る


④ 状態を持つと、台を増やせない

ここからが冒頭のログイン事故です。実際に壊します。

2台のアプリを作る

app.mjs を1つ書いて、ポート番号だけ変えて2つ起動します。

bash
$ nano ~/cslab/scale/app.mjs
import http from 'node:http';
import fs from 'node:fs';
import crypto from 'node:crypto';

const PORT  = Number(process.argv[2]);
const STORE = process.argv[3] || 'mem';   // mem = 自分のメモリ / file = 外に出す
const NAME  = `app:${PORT}`;
const FILE  = './sessions.json';

const mem = new Map();
const load = () => { try { return JSON.parse(fs.readFileSync(FILE, 'utf8')); } catch { return {}; } };
const save = (o) => fs.writeFileSync(FILE, JSON.stringify(o));

const get = (sid)    => STORE === 'mem' ? mem.get(sid) : load()[sid];
const set = (sid, v) => { if (STORE === 'mem') mem.set(sid, v); else { const o = load(); o[sid] = v; save(o); } };

http.createServer((req, res) => {
  const cookie = (req.headers.cookie || '').match(/sid=([a-f0-9]+)/);
  const sid = cookie ? cookie[1] : null;

  if (req.url === '/login') {
    const newSid = crypto.randomBytes(8).toString('hex');
    set(newSid, { user: 'koki' });
    res.setHeader('Set-Cookie', `sid=${newSid}; Path=/`);
    res.end(`${NAME} ログインしました sid=${newSid}\n`);
    return;
  }
  const s = sid && get(sid);
  res.end(s ? `${NAME} ようこそ ${s.user} さん\n` : `${NAME} ログインしてください\n`);
}).listen(PORT, () => console.log(`${NAME} (${STORE}) 起動`));

Cookie にはランダムなIDしか入れていません。 「誰か」を覚えているのはサーバー側です。 これは本線の パスワードは保存しない — セッションとJWT でやった形と同じです。

前に振り分ける役を作る

bash
$ nano ~/cslab/scale/lb.mjs
import http from 'node:http';
const BACKENDS = [3001, 3002];
let i = 0;
http.createServer((req, res) => {
  const port = BACKENDS[i++ % BACKENDS.length];        // ⚠️ ラウンドロビン(順番に回すだけ)
  const p = http.request({ port, path: req.url, method: req.method, headers: req.headers }, (br) => {
    res.writeHead(br.statusCode, br.headers); br.pipe(res);
  });
  req.pipe(p);
}).listen(3000, () => console.log('lb  :3000 -> 3001, 3002 で交互に振り分け'));

30行未満です。ロードバランサが特別なものではないことは、書いてみるとすぐ分かります。

3つ起動する

bash
$ cd ~/cslab/scale
$ node app.mjs 3001 mem &
$ node app.mjs 3002 mem &
$ node lb.mjs &
app:3001 (mem) 起動
app:3002 (mem) 起動
lb  :3000 -> 3001, 3002 で交互に振り分け

壊す

ログインして、同じCookieのまま5回アクセスします。

bash
$ curl -s -c cookies.txt http://127.0.0.1:3000/login
$ for i in 1 2 3 4 5; do curl -s -b cookies.txt http://127.0.0.1:3000/; done
app:3001 ログインしました sid=840fa285e29d46a2

app:3002 ログインしてください
app:3001 ようこそ koki さん
app:3002 ログインしてください
app:3001 ようこそ koki さん
app:3002 ログインしてください

これが、私が本番でやった事故そのものです。

  • Cookie は毎回同じものを送っています(-b cookies.txt)
  • アプリのコードも変えていません
  • 1台のときは完全に動きます

壊れているのは振り分けた結果です。ログインを受け付けたのは 3001。 2回に1回は 3002 に飛び、3002 は 840fa285e29d46a2 というIDを見たことがありません。

「たまにログアウトする」というバグ報告の、かなりの割合がこれです。 再現しないのではなく、台数ぶんの周期で再現します。

直す — 状態を外に出す

app.mjs は最初から2モード書いてあります。file にすると、セッションを両方から見えるファイルに置きます。

bash
$ # いったん全部止める
$ kill %1 %2 2>/dev/null; sleep 1
$ rm -f sessions.json cookies.txt
$ node app.mjs 3001 file &
$ node app.mjs 3002 file &

同じことをやります。

bash
$ curl -s -c cookies.txt http://127.0.0.1:3000/login
$ for i in 1 2 3 4 5 6; do curl -s -b cookies.txt http://127.0.0.1:3000/; done
app:3001 ログインしました sid=8b2f04365b01bb4b

app:3002 ようこそ koki さん
app:3001 ようこそ koki さん
app:3002 ようこそ koki さん
app:3001 ようこそ koki さん
app:3002 ようこそ koki さん
app:3001 ようこそ koki さん

直りました。 3001 と 3002 が交互に答えているのは変わりません。変わったのは、どちらもセッションを見られることです。

中身も見えます。

bash
$ cat sessions.json
{"8b2f04365b01bb4b":{"user":"koki"}}

📸 スクリーンショット2: mem のときの「ログインしてください」が交互に出る出力と、 file にしたあと全部「ようこそ」になる出力を上下に並べて残す

「ステートレスにする」は前提条件であって、おまけではない

ここで一般化します。

サーバーが持っている状態台を増やすとどうなるか逃がし先
セッションログインが交互に切れる(いまやった)Redis / DB / 署名付きトークン
アップロードされたファイル1号機に上げたファイルが2号機で404オブジェクトストレージ / 共有ボリューム
メモリ上のキャッシュ台ごとに中身が違う。 消したのに古い値が返るRedis などの共有キャッシュ
カウンタ・連番番号が重複する(②の競合状態と同じ形)DBのシーケンス / 共有カウンタ
WebSocketの接続別の台に繋がった人へは届かない共有のPub/Sub
cron的な定期処理台数ぶん同時に走る。 メールが3通届く実行するのは1台だけにする仕組み

この表の左側が1つでも残っていると、水平スケールは静かに壊れます。 落ちるのではなく、たまに変になる形で壊れるのが厄介なところです。

実務では、ファイルではなく Redis を使うのが普通です。理由は速さと期限切れを自動で消せること。 本線の キャッシュは消すのが一番難しい — Redisの導入 でやった通りです。

ただし、Redis に出した瞬間に「Redis が落ちたら全台が死ぬ」構造になります。 状態は消えたのではなく、1箇所に集めただけです。ここは正直に受け止める必要があります。


⑤ プロキシ — フォワードとリバースは、まったく別のもの

名前が似ているせいで、私はしばらく「同じものの向きが違うだけ」だと思っていました。違います。立つ場所が違います。

【フォワードプロキシ】クライアント側に立つ
                      ↓ここ
  社員PC ─┬─→ [proxy] ─→ インターネット ─→ 目的のサイト
  社員PC ─┤
  社員PC ─┘
  ⚠️ 目的のサイトから見えるのは proxy のIP。誰が見に来たか分からない


【リバースプロキシ】サーバー側に立つ
                                  ここ↓
  利用者 ─→ インターネット ─→ [nginx] ─┬─→ app:3001
                                        └─→ app:3002
  ⚠️ 利用者から見えるのは nginx だけ。後ろに何台いるか分からない
フォワードプロキシリバースプロキシ
立つ場所クライアント側サーバー側
誰のために働くか見に行く人見せる側
設定するのは誰かクライアント(ブラウザ・OS)サーバーの管理者
隠すものクライアントの正体バックエンドの構成
サーバー側は知っているか知らない。 設定していない自分で立てている
代表的な用途社内から外部への出口制御、キャッシュ振り分け・TLS終端・静的配信
代表的なソフトSquidnginx・HAProxy・Envoy

「プロキシを入れたい」と言われたとき、どちらの話かを最初に確認しないと、まったく違うものを作ります。

リバースプロキシを立てる

nginx を入れて、さっきの2台に振り分けさせます。

bash
$ sudo apt update
$ sudo apt install -y nginx

設定を書きます。設定ファイルの場所は /etc/nginx/sites-available/ です。

bash
$ sudo nano /etc/nginx/sites-available/scale
upstream backend {
    server 127.0.0.1:3001;
    server 127.0.0.1:3002;
}

server {
    listen 8080;

    location / {
        proxy_pass http://backend;

        # ⚠️ これを書かないと、アプリ側は「全員が127.0.0.1から来た」と思う
        proxy_set_header Host              $host;
        proxy_set_header X-Real-IP         $remote_addr;
        proxy_set_header X-Forwarded-For   $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

有効にして、構文を確かめてから読み込みます。

bash
$ sudo ln -s /etc/nginx/sites-available/scale /etc/nginx/sites-enabled/
$ sudo nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
bash
$ sudo systemctl reload nginx
$ curl -s http://127.0.0.1:8080/

upstream に2台書いてあるので、nginx が交互に振り分けます。 本線の ポート番号を隠す — nginxのリバースプロキシ と同じ形です。

nginx -t を必ず打ってください。 構文が間違ったまま reload すると、 いま動いている nginx がそのまま動き続けて、変更が入っていないことに気づけません。

バックエンドのポートが外から見えなくなることを確かめる

ここが本題です。アプリが 0.0.0.0 で待っていると、外から直接3001に繋がれます。 nginx を通す意味がありません。待つアドレスを 127.0.0.1 に絞ります。(④の app.mjs と lb.mjs は listen にアドレスを書いていないので、全部の口で待っています。ここでは小さなサーバーで確かめます。④で起動した 3001 番が動いたままだと EADDRINUSE で立ち上がらないので、先に pkill -f "app.mjs 3001" で止めてください)

bash
$ node -e "require('http').createServer((q,s)=>s.end('backend ok\n')).listen(3001,'127.0.0.1',()=>console.log('3001 は 127.0.0.1 だけで待っている'))" &
3001 は 127.0.0.1 だけで待っている

自分のIPを調べて、2通りで叩きます。(下の出力は、見やすいように見出しの行を足して整えています)

bash
$ ip -4 addr show | grep inet
$ curl -s --max-time 3 http://127.0.0.1:3001/
$ curl -s --max-time 3 http://10.212.144.184:3001/ || echo "(接続できない)"
このマシンのIP: 10.212.144.184

--- 127.0.0.1 から ---
backend ok
--- 10.212.144.184 から(同じマシンでも別アドレス) ---
(接続できない)

理由を見ます。

bash
$ curl -sv --max-time 3 http://10.212.144.184:3001/ 2>&1 | grep -iE "connect|refused|failed"
* connect to 10.212.144.184 port 3001 from 0.0.0.0 port 64819 failed: Connection refused
* Failed to connect to 10.212.144.184 port 3001 after 2042 ms: Could not connect to server
* closing connection #0

同じマシンなのに、127.0.0.1 では繋がり、LANのIPでは Connection refused。 待っているアドレスが違うだけです。ファイアウォールは一切触っていません。

これが「バックエンドのポートを外から消す」ということです。 外に開いているのは nginx の 80/443 だけ。アプリのポートは、そもそも外を向いていない。

リバースプロキシが肩代わりするもの

nginx を1枚挟むと、アプリが書かなくてよくなる仕事が一気に増えます。

肩代わりするものアプリ側でやると何が起きるか
TLS終端全アプリに証明書を配ることになる。更新も台数ぶん
圧縮(gzip / brotli)アプリのCPUが圧縮に使われる。 本来の処理が遅くなる
キャッシュ同じ結果を毎回作り直す
振り分けクライアントが「どの台か」を知る必要が出る
静的ファイルの配信画像1枚のためにアプリのプロセスが1つ埋まる
接続の受け止め遅い回線の相手にアプリが付き合わされる
リクエストサイズ制限・タイムアウト全アプリに同じコードを書く

一番効くのは「静的ファイルの配信」です。 そして、それをさらに外へ出すのが CDN です。


⑥ CDN を「計算の外出し」として見る

CDNを「速くする道具」と覚えると、何が速くなるのか分からなくなります。やっていることは2つだけです。

  1. 距離を消す。 物理的に近い場所から返す
  2. 同じものを何度も返す仕事を、元サーバーから取り上げる

2つ目のほうが、個人開発では効きます。どれくらい効くのか、自分のサイトで測ります。

測るのは curl -I(ヘッダだけ)と、1回の curl までにしてください。 自分のサイトでも、繰り返し叩けば負荷です。負荷をかける実験は、自分で立てたローカルのサーバーに対してだけ行います。

HTMLの大きさを測る

bash
$ curl -s -o /dev/null -w 'HTML本体: %{size_download} バイト  時間: %{time_total}s\n' https://obmes.com/
HTML本体: 81862 バイト  時間: 0.132589s

静的ファイルの大きさを測る

HTMLの中から読み込まれているファイルを、ヘッダだけ見ます。

bash
$ for u in themes/swell/assets/img/no_img.png \
           themes/swell/assets/js/plugins/lazysizes.min.js \
           themes/swell/assets/js/plugins/swiper.min.js \
           themes/swell/build/css/main.css \
           themes/swell/build/js/main.min.js ; do
$   printf "%-52s " "$u"
$   curl -sI "https://obmes.com/wp-content/$u" | grep -iE '^(content-length|cache-control)' | tr -d '\r' | tr '\n' ' '
$   echo
$ done
themes/swell/assets/img/no_img.png                   Content-Length: 102 Cache-Control: max-age=604800
themes/swell/assets/js/plugins/lazysizes.min.js      Content-Length: 12719 Cache-Control: max-age=604800
themes/swell/assets/js/plugins/swiper.min.js         Content-Length: 134961 Cache-Control: max-age=604800
themes/swell/build/css/main.css                      Content-Length: 83451 Cache-Control: max-age=604800
themes/swell/build/js/main.min.js                    Content-Length: 16949 Cache-Control: max-age=604800

比率を出す

bash
$ node -e "
  const s=[102,12719,134961,83451,16949];
  const h=81862;
  const t=s.reduce((a,b)=>a+b,0);
  console.log('静的合計', t, 'バイト');
  console.log('HTML    ', h, 'バイト');
  console.log('静的の割合', (t/(t+h)*100).toFixed(1)+'%');
  "
静的合計 248182 バイト
HTML     81862 バイト
静的の割合 75.2%
バイト数割合Cache-Control
HTML81,86224.8%付いていない(毎回、元サーバーが作る)
静的ファイル(5本)248,18275.2%max-age=604800(1週間キャッシュしてよい)

転送量の75%は、1週間まったく変わらないファイルです。

さらに大事なのはリクエストの本数です。1ページ表示するのに、HTMLは1本、静的ファイルは5本以上。 元サーバーが受けるリクエストの大半は、毎回まったく同じ中身を返すだけの仕事です。

静的ファイルを CDN に出すと、元サーバーの仕事はこの割合ぶんそのまま消えます。 このサイトなら、転送量の75%と、リクエストの大半が元サーバーに来なくなります。 記事の内容を1文字も変えず、コードも1行も書かずに、です。

そして、Cache-Control が付いていないHTMLは、CDN に置いても勝手にはキャッシュされません。 これは事故ではなく設計です。記事を直したのに古いHTMLが返り続けたら困るからです。

CDNは「魔法で速くなる箱」ではなく、「Cache-Control が付いているものだけを預かってくれる箱」です。 だから CDN を入れる前にやることは、何にどれだけの max-age を付けるかを決めることになります。 ここは本線の キャッシュは4箇所にある — Cache-ControlとCDN が詳しいです。


⑦ ボトルネックは1つしかない

ここまで「並列にする」「台を増やす」をやってきました。でも、増やす前に確かめることがあります。

どこかが詰まっているとき、詰まっているのは1箇所です。 そこ以外を直しても、1ミリも速くなりません。

何を見れば分かるか

詰まっているもの見るコマンドその値がこうなっていたら
CPUtop / htop%Cpu(s) の us + sy が90%超え。ロードアベレージがコア数を超えている
CPU(待たされている)vmstat 1r 列(実行待ちの数)がコア数より大きい
メモリfree -havailable が小さい。used ではなく available を見る
メモリ(限界)vmstat 1si / so(スワップ)が0でない。 これが出たら他は見なくていい
ディスクI/Oiostat -x 1%util が100%近い。 await(待ち時間)が跳ねている
ディスクI/O(間接)vmstat 1wa(I/O待ち)が高い。 CPUは暇なのに遅い、の正体
ネットワークss -s / ip -s link接続数が異常に多い。ss -s の TIME-WAIT が数万
DBコネクションss -tn state establishedDBへの接続数が上限に張り付いている。 アプリ側は「待ち」に見える

iostat は入っていないことがあります。

bash
$ sudo apt install -y sysstat

実測 — ディスクで詰まっているときに、CPUを増やしても意味がない

言葉で「意味がない」と言われても納得できないので、同じ形の実験を2つやります。

  • CPUを使う仕事をワーカー1/2/4/8個に割る
  • ディスクを使う仕事(fsync 付きの書き込み)をワーカー1/2/4/8個に割る
bash
$ nano ~/cslab/scale/bottleneck.mjs
import { Worker, isMainThread, parentPort, workerData } from 'node:worker_threads';
import fs from 'node:fs';

function cpuTask(n) {
  let x = 0;
  for (let i = 0; i < n * 3_000_000; i++) x = (x + Math.sqrt(i % 997)) % 99991;
  return x;
}

function ioTask(n, id) {                        // ディスクに同期書き込みする仕事
  const buf = Buffer.alloc(64 * 1024, 65);
  for (let i = 0; i < n; i++) {
    const fd = fs.openSync(`./io_${id}_${i}.tmp`, 'w');
    fs.writeSync(fd, buf);
    fs.fsyncSync(fd);                           // ⚠️ 本当にディスクへ書くまで待つ
    fs.closeSync(fd);
    fs.unlinkSync(`./io_${id}_${i}.tmp`);
  }
}

if (!isMainThread) {
  const { kind, n, id } = workerData;
  kind === 'cpu' ? cpuTask(n) : ioTask(n, id);
  parentPort.postMessage('done');
} else {
  const t = () => Number(process.hrtime.bigint()) / 1e6;
  const CPU_TOTAL = 24, IO_TOTAL = 240;

  async function run(kind, workers) {
    const total = kind === 'cpu' ? CPU_TOTAL : IO_TOTAL;
    const t0 = t();
    await Promise.all([...Array(workers)].map((_, id) => new Promise((res, rej) => {
      const w = new Worker(new URL(import.meta.url), { workerData: { kind, n: total / workers, id } });
      w.on('error', rej); w.on('exit', res);
    })));
    return t() - t0;
  }

  for (const kind of ['cpu', 'io']) {
    const base = await run(kind, 1);
    const out = [`1: ${base.toFixed(0)}ms (1.00倍)`];
    for (const n of [2, 4, 8]) {
      const ms = await run(kind, n);
      out.push(`${n}: ${ms.toFixed(0)}ms (${(base / ms).toFixed(2)}倍)`);
    }
    console.log(`${kind === 'cpu' ? 'CPUを使う仕事 ' : 'ディスクを使う仕事'}  ` + out.join('  '));
  }
}
bash
$ node ~/cslab/scale/bottleneck.mjs
CPUを使う仕事   1: 968ms (1.00倍)  2: 655ms (1.48倍)  4: 412ms (2.35倍)  8: 262ms (3.70倍)
ディスクを使う仕事  1: 595ms (1.00倍)  2: 409ms (1.46倍)  4: 400ms (1.49倍)  8: 400ms (1.49倍)

並べます。

ワーカー数CPUを使う仕事ディスクを使う仕事
1968ms(1.00倍)595ms(1.00倍)
2655ms(1.48倍)409ms(1.46倍)
4412ms(2.35倍)400ms(1.49倍)
8262ms(3.70倍)400ms(1.49倍)

ディスク側は、2ワーカーで頭打ちになり、そこから4倍にしても8倍にしても、1ミリ秒も速くなっていません。

400ms、400ms。 見事に同じです。ワーカーを4倍にした費用が、まるごと無駄になっています。

これが「ボトルネックは1つしかない」という言葉の中身です。 このとき top を見ると、CPUは暇です。 だから「CPUに余裕があるから、もっと並列にしよう」と考えます。 その判断が、いちばんやってはいけないことです。

vmstat 1 の wa(I/O待ち)が高いとき、CPUは「暇」ではなく「待たされて」います。 ここでワーカーを増やすと、待つ人が増えるだけです。

順番

  1. 測る(上の表のコマンドで、詰まっている1つを特定する)
  2. その1つを直す
  3. もう一度測る。 ボトルネックは別の場所に移っています
  4. 目標に届くまで、1〜3を繰り返す

3が抜けると、「前に効いた対策」を効かない場所に打ち続けることになります。 本線の ボトルネックは動く — 負荷分散とキャッシュの設計 が、まさにこの話です。

📸 スクリーンショット3: node ~/cslab/scale/bottleneck.mjs の出力。 ディスク側が 4 と 8 でまったく同じ数字になっている行が読めるように撮る


⑧ 最初の言語をどう選ぶか

roadmap.sh には「言語を1つ選ぶ」という項目があります。そこで止まる人が多いところです。私も止まりました。

このサイトの答え

JavaScript から始めました。 理由は3つです。

選んだ理由具体的に何が助かったか
フロントとバックが同じ言語文法を2回学ばなくていい。 画面もAPIも同じ書き方で書ける
ブラウザに最初から入っているインストールが要らない。 F12を開けばその場で動く。1日目に何かが動く
情報が圧倒的に多いエラーメッセージで検索すれば、ほぼ必ず答えがある

3つ目が、実は一番効きました。初学者が詰まるのは文法ではなく、詰まったときに調べられないことです。

その代償

正直に書きます。JavaScript から始めたことで、余計に苦しんだところが2つあります。

代償どう出たか
型が無い"1" + 1 が "11" になる。間違いが実行するまで分からない。 結局あとから TypeScript を入れることになった
非同期が最初からつらいfetch の結果が undefined になる。「上から順に実行される」という思い込みが最初に壊される言語

この2つは、本線で正面から扱いました。 「1」と 1 は等しい — JavaScriptの基本と最初の落とし穴 が入口です。

もし「型がある言語から始めたほうがよかったか」と聞かれたら、私の答えは「どちらでもよかった」です。 どちらを選んでも、選ばなかったほうの利点を、あとで痛みとして知ることになります。 それでいいと思っています。

何を作りたいかで選ぶ

作りたいもの向いている言語理由
Webサイト・WebアプリJavaScript / TypeScriptブラウザで動くのはこれだけ。 選択の余地が無い
WebのバックエンドだけJavaScript / Go / Python / PHPどれでも書ける。チームが使っているものが正解
スマホアプリSwift(iOS) / Kotlin(Android)各社の公式。 1つのコードで両方なら React Native / Flutter
データ分析・機械学習Pythonライブラリが全部ここにある。 他を選ぶ理由がほぼ無い
組み込み・OSC / Rustメモリを自分で管理できる言語でないと書けない
サーバーの道具・CLIGo / Rust実行ファイル1つで配れる。 相手のマシンに何も入れさせない
業務システム(既存)Java / C#すでに動いているものが多い。 選ぶというより、そこにある

表を見て「Pythonのほうがよさそう」と思ったなら、それでいいです。 大事なのは選ぶことではなく、選んだ1つで何かを最後まで作ることです。

結論 — 最初の1つは何でもよい

これは投げやりな結論ではありません。理由があります。

1つ目の言語では、言語の性質と、プログラミング一般の性質の区別がつきません。 変数、条件分岐、ループ、関数、配列。これらは全部の言語にあります。 1つ目を学んでいるとき、あなたは「JavaScript」を学んでいるのではなく、「プログラミング」を学んでいます。

2つ目を学んだときに、初めて「言語の地図」ができます。 「あ、これはどの言語にもある」「これはこの言語だけの都合だ」が、比較して初めて分かるからです。

だから、2つ目に進む価値は「もう1つ書けるようになる」ことではありません。 1つ目で覚えたことのうち、どれが本質でどれが方言だったのかが分かることです。

このサイトでは、2つ目と3つ目を本線でやっています。

同じAPIを3つの言語で書きました。 そこで初めて、「非同期のつらさは JavaScript の都合だった」と分かりました。


後片づけ

立てたものを全部止めます。

bash
$ jobs
$ kill %1 %2 %3 2>/dev/null

残っていないか確認します。

bash
$ ss -tlnp | grep -E ':(3000|3001|3002|8080)' || echo "(全部止まっています)"
(全部止まっています)

nginx の設定を戻します。

bash
$ sudo rm /etc/nginx/sites-enabled/scale
$ sudo nginx -t && sudo systemctl reload nginx

作業ディレクトリを消します。

bash
$ ls ~/cslab/scale
$ rm -rf ~/cslab/scale
$ ls ~/cslab

rm -rf は戻せません。 パスを打つ前に、必ず ls で中身を見てから打ってください。

nginx を入れたままにしておくのは構いません。 動いているのは 80 番だけで、実験用の 8080 は消しました。


まとめ — 理解できたこと

  • 垂直(1台を強くする)には上限があり、水平(台数を増やす)には上限が無い。 ただし垂直のほうが圧倒的に簡単で、たいていの個人開発はそこで終わってよい
  • 水平にすると増えるのは性能だけではなく、壊れる場所の数。 ログが散り、設定が散り、同期の問題が出る
  • アムダールの法則 1 / ((1-p) + p/n)。上限は 1/(1-p) で、台数はまったく出てこない
  • 95%並列化できても、無限に台を増やして20倍まで。 90%なら10倍。直列部分を削るほうが、台数を増やすより効く
  • 実測は理論値にすら届かない。 p=95.6% の処理で、8ワーカーの理論値6.12倍に対して実測4.53倍
  • 1台増やして得られる分は減り続ける。 実測で 7台目が +0.58倍、8台目が +0.26倍。どこかで買うのをやめる判断が要る
  • グスタフソンの法則は「問題を大きくするなら話が変わる」という別の見方。 「速く終わらせたい」ときはアムダールに当たる
  • メモリにセッションを持つサーバーを2台にすると、リクエストごとに交互にログアウトする。 Cookie もコードも正しいまま壊れる
  • 「たまにログアウトする」は再現しないのではなく、台数ぶんの周期で再現する
  • セッションを外に出すと直る。 ただし状態は消えたのではなく1箇所に集まっただけで、そこが落ちれば全台が死ぬ
  • ステートレスは水平スケールのおまけではなく前提条件。 ファイル・キャッシュ・連番・定期処理も同じ形で壊れる
  • フォワードプロキシとリバースプロキシは立つ場所が逆。 隠すものが「クライアントの正体」と「バックエンドの構成」で正反対
  • 待つアドレスを 127.0.0.1 に絞るだけで、同じマシンのLAN IPからも Connection refused になる。 ファイアウォールを触らずにポートが外から消える
  • CDNは魔法の箱ではなく、Cache-Control が付いているものだけを預かる箱。 だから先にキャッシュ方針を決める
  • このサイトの実測で、転送量の75.2%が静的ファイル。 しかも全部 max-age=604800。HTMLには Cache-Control が付いていない
  • ボトルネックは1つしかない。 ディスクで詰まっている状態でワーカーを4個から8個にしても、400ms → 400ms でまったく変わらなかった
  • wa が高いときのCPUは「暇」ではなく「待たされている」。 ここで並列度を上げるのが一番やってはいけない判断
  • 直したらもう一度測る。 ボトルネックは別の場所へ移る
  • 最初の言語は何でもよい。 2つ目を学んだときに初めて、どれが本質でどれが方言だったかが分かる

このシリーズの解説は、ここで終わりです。24回ありました。 最後に、到達作品で自作の KV ストアを作り、ここまでの理屈を実測します。

振り返ってみると、身についたのはアルゴリズムの名前ではありませんでした。 二分探索も、ハッシュ表も、ダイクストラも、必要になったときに調べれば書けます。

身についたのは、測ってから決める、という手つきのほうでした。 このシリーズで、私の予想は何度も外れています。 特に印象に残っている3つを挙げます。

  1. 計算量が同じでも、配列のほうが速かった。 連結リストは理屈の上では有利なはずなのに、

実測ではキャッシュに乗る配列が勝つ場面が何度もありました (先頭への追加が数百倍遅い — コンピュータ科学深掘り)

  1. 1回しか引かないなら、並べないほうが速かった。 「まずソートする」は、

検索が1回きりならソートのぶんだけ損をします (1回引くだけなら並べると損 — コンピュータ科学深掘り)

  1. 台数を増やしても頭打ちになった。 この記事です。8倍にして4.53倍。理論値の6.12倍にも届きませんでした

3つとも、頭の中では正しかった判断です。 測って初めて間違いだと分かりました。 だから、このシリーズで一番残しておきたいのはこの1行です。

速くする前に、必ず測る。測る前の判断は、だいたい外れる。

本線に戻ってください。 全体の順路は はじめに にあります。


参考リンク


次に読む

この記事は 【深掘り】コンピュータ科学 の 24 / 25 本目です。

記事
← 前の記事公開鍵暗号とTLS — 鍵は渡さずに秘密を共有する
→ 次の記事自作KVストアで理屈を実測する — CSの到達作品

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

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

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

›CS — Scaling
  • アムダールの法則で頭打ちになる
  • 状態を持つと台を増やせない

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

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

コメント

コメントする

目次