※本記事はアフィリエイト広告(PR)を含みます。
状態を持つと、台数を増やしても速くなりません。アムダールの法則で、増やせる限界を数字で確かめます。
これは【深掘り】の記事です。本線の順路ではありません。 そして、このコンピュータ科学 深掘りシリーズの、解説としては最後の回です(このあとに到達作品が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つ目を学んだときに、初めて「言語の地図」ができる
この記事でやること
- 垂直と水平を表で対比する(上限・停止が要るか・コスト曲線・複雑さ)
- アムダールの法則を式で出し、並列化率 50% / 90% / 95% / 99% の上限を計算して表にする
- JavaScript で「一部だけ並列にできる処理」を書き、ワーカー数1〜8で実測して頭打ちを確認する
- メモリにセッションを持つサーバーを2台立て、ログイン状態が消えるところを再現し、外に出して直す
- リバースプロキシを立て、バックエンドのポートが外から見えなくなることを確かめる
- 自分のサイトの静的ファイルとHTMLの転送量を実測し、比率を出す
- ディスクで詰まらせた状態でワーカーを増やし、速くならないことを実測する
- 最初の言語の選び方を表にして、このシリーズ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台目とロードバランサとセッション共有を持ち込むのは、負けです。 増えるのは性能ではなく、壊れる場所の数です。
判断の順番はこうです。
- 測る。 どこが詰まっているか特定する(⑦ でやります)
- 直す。 コードやSQLで直せるなら、それが一番安い
- 垂直。 1台を強くして届くなら、それで終わり
- 水平。 上の3つで届かないときだけ
私は最初、1をすっ飛ばして4をやりました。 その結果が、この記事の冒頭のログイン事故です。
垂直スケールを小さな単位で試すなら、プランが段階的に用意されたVPSが向いています。シンVPS
の大容量メモリプランは1GB(1コア)・2GB(2コア)・4GB(3コア)と段階があり、1GBは1ヶ月契約750円〜36ヶ月契約で月451円(2026-11時点、税込)です。無料のお試し期間は無く最低利用期間が3ヶ月で、安い月額は36ヶ月契約の価格なので、契約期間は用途に合わせて選んでください。
② アムダールの法則
「4台にすれば4倍」がなぜ成り立たないかを、式から出します。
準備 — 作業場所を作る
コア数を確認します。
8
4より小さい場合は、VMware の設定でコアを増やしてから続けてください。 1コアだと、この実験はそもそも成立しません。
式
処理全体のうち、並列にできる割合を p とします(残りの 1 - p は、どうやっても1本でしか走らない部分)。 台数(ワーカー数)を n とすると、速度の倍率はこうなります。
1
速度倍率 = ─────────────
(1 - p) + p/n
n を無限に大きくすると、p/n は 0 に近づきます。 残るのは (1 - p) だけ。つまり、
1
上限 = ───────────
1 - p
上限は、台数ではなく「並列にできない部分の割合」だけで決まります。
計算してみる
p を変えて、実際に数を出します。
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つあります。
- 95%並列化できても、上限は20倍。 「ほとんど並列にできている」つもりでも、そこで止まります
- 90%と99%で、上限が10倍違う。 差は「残りの1割か1分か」だけ。直列部分を削るほうが、台数を増やすより効く
- 64台にしたときの効率を見る。 95%のとき 15.42倍 ÷ 64台 = 1台あたり24%しか働いていません
だから「並列にできない部分」を探すのが先です。 起動処理、設定の読み込み、最後の集計、DBへの1本の書き込み。ここが
1 - pです。
グスタフソンの法則 — 前提が違えば結論も違う
アムダールの法則は「仕事の量を固定して、速く終わらせる」話です。 これに対してグスタフソンの法則は、「台数が増えたなら、もっと大きい問題を解けばいい」という見方をします。
現実には、台数を増やす理由は「同じ処理を速く」ではなく「もっと多くのユーザーを捌く」であることが多い。 その場合、直列部分の割合は問題を大きくしても増えないので、頭打ちの形が変わります。
この記事で扱うのはアムダールのほうです。 「1つの処理を速くしたい」ときは、必ずアムダールに当たるからです。 グスタフソンが効くのは「捌く量を増やしたい」ときで、それは水平スケールの本来の目的でもあります。
③ 実測 — 理論どおり頭打ちになるか
式が正しくても、現実はさらに悪いはずです。ワーカーの起動、データの受け渡し、メモリの取り合い。 実際に測ります。
「一部だけ並列にできる処理」を書く
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 の実際の値が要ります。
直列部分(10単位): 286 ms
並列にできる部分(200単位): 6246 ms
合計: 6532 ms 並列化できる割合 p = 95.6%
理論上限(1/(1-p)) = 22.8倍
この処理は 95.6% が並列化できます。台数を無限に増やしても、22.8倍が上限です。
走らせる
ワーカー数 実測(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%) | 差 |
|---|---|---|---|---|
| 1 | 5782 | 1.00 | 1.00 | — |
| 2 | 3474 | 1.66 | 1.92 | −0.26 |
| 3 | 2299 | 2.52 | 2.76 | −0.24 |
| 4 | 1956 | 2.96 | 3.53 | −0.57 |
| 5 | 1646 | 3.51 | 4.25 | −0.74 |
| 6 | 1565 | 3.69 | 4.92 | −1.23 |
| 7 | 1355 | 4.27 | 5.54 | −1.27 |
| 8 | 1277 | 4.53 | 6.12 | −1.59 |
読み取れることが3つあります。
- 8ワーカーで 4.53倍。8倍にはまったく届いていません
- 理論値にも届いていません。 理論6.12倍に対して実測4.53倍。しかも差は台数が増えるほど広がっています
- 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つ起動します。
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 でやった形と同じです。
前に振り分ける役を作る
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つ起動する
app:3001 (mem) 起動
app:3002 (mem) 起動
lb :3000 -> 3001, 3002 で交互に振り分け
壊す
ログインして、同じCookieのまま5回アクセスします。
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 にすると、セッションを両方から見えるファイルに置きます。
同じことをやります。
app:3001 ログインしました sid=8b2f04365b01bb4b
app:3002 ようこそ koki さん
app:3001 ようこそ koki さん
app:3002 ようこそ koki さん
app:3001 ようこそ koki さん
app:3002 ようこそ koki さん
app:3001 ようこそ koki さん
直りました。 3001 と 3002 が交互に答えているのは変わりません。変わったのは、どちらもセッションを見られることです。
中身も見えます。
{"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終端・静的配信 |
| 代表的なソフト | Squid | nginx・HAProxy・Envoy |
「プロキシを入れたい」と言われたとき、どちらの話かを最初に確認しないと、まったく違うものを作ります。
リバースプロキシを立てる
nginx を入れて、さっきの2台に振り分けさせます。
設定を書きます。設定ファイルの場所は /etc/nginx/sites-available/ です。
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;
}
}
有効にして、構文を確かめてから読み込みます。
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
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" で止めてください)
3001 は 127.0.0.1 だけで待っている
自分のIPを調べて、2通りで叩きます。(下の出力は、見やすいように見出しの行を足して整えています)
このマシンのIP: 10.212.144.184
--- 127.0.0.1 から ---
backend ok
--- 10.212.144.184 から(同じマシンでも別アドレス) ---
(接続できない)
理由を見ます。
* 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つだけです。
- 距離を消す。 物理的に近い場所から返す
- 同じものを何度も返す仕事を、元サーバーから取り上げる
2つ目のほうが、個人開発では効きます。どれくらい効くのか、自分のサイトで測ります。
測るのは
curl -I(ヘッダだけ)と、1回のcurlまでにしてください。 自分のサイトでも、繰り返し叩けば負荷です。負荷をかける実験は、自分で立てたローカルのサーバーに対してだけ行います。
HTMLの大きさを測る
HTML本体: 81862 バイト 時間: 0.132589s
静的ファイルの大きさを測る
HTMLの中から読み込まれているファイルを、ヘッダだけ見ます。
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
比率を出す
静的合計 248182 バイト
HTML 81862 バイト
静的の割合 75.2%
| バイト数 | 割合 | Cache-Control | |
|---|---|---|---|
| HTML | 81,862 | 24.8% | 付いていない(毎回、元サーバーが作る) |
| 静的ファイル(5本) | 248,182 | 75.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ミリも速くなりません。
何を見れば分かるか
| 詰まっているもの | 見るコマンド | その値がこうなっていたら |
|---|---|---|
| CPU | top / htop | %Cpu(s) の us + sy が90%超え。ロードアベレージがコア数を超えている |
| CPU(待たされている) | vmstat 1 | r 列(実行待ちの数)がコア数より大きい |
| メモリ | free -h | available が小さい。used ではなく available を見る |
| メモリ(限界) | vmstat 1 | si / so(スワップ)が0でない。 これが出たら他は見なくていい |
| ディスクI/O | iostat -x 1 | %util が100%近い。 await(待ち時間)が跳ねている |
| ディスクI/O(間接) | vmstat 1 | wa(I/O待ち)が高い。 CPUは暇なのに遅い、の正体 |
| ネットワーク | ss -s / ip -s link | 接続数が異常に多い。ss -s の TIME-WAIT が数万 |
| DBコネクション | ss -tn state established | DBへの接続数が上限に張り付いている。 アプリ側は「待ち」に見える |
iostat は入っていないことがあります。
実測 — ディスクで詰まっているときに、CPUを増やしても意味がない
言葉で「意味がない」と言われても納得できないので、同じ形の実験を2つやります。
- CPUを使う仕事をワーカー1/2/4/8個に割る
- ディスクを使う仕事(
fsync付きの書き込み)をワーカー1/2/4/8個に割る
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(' '));
}
}
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を使う仕事 | ディスクを使う仕事 |
|---|---|---|
| 1 | 968ms(1.00倍) | 595ms(1.00倍) |
| 2 | 655ms(1.48倍) | 409ms(1.46倍) |
| 4 | 412ms(2.35倍) | 400ms(1.49倍) |
| 8 | 262ms(3.70倍) | 400ms(1.49倍) |
ディスク側は、2ワーカーで頭打ちになり、そこから4倍にしても8倍にしても、1ミリ秒も速くなっていません。
400ms、400ms。 見事に同じです。ワーカーを4倍にした費用が、まるごと無駄になっています。
これが「ボトルネックは1つしかない」という言葉の中身です。 このとき top を見ると、CPUは暇です。 だから「CPUに余裕があるから、もっと並列にしよう」と考えます。 その判断が、いちばんやってはいけないことです。
vmstat 1のwa(I/O待ち)が高いとき、CPUは「暇」ではなく「待たされて」います。 ここでワーカーを増やすと、待つ人が増えるだけです。
順番
- 測る(上の表のコマンドで、詰まっている1つを特定する)
- その1つを直す
- もう一度測る。 ボトルネックは別の場所に移っています
- 目標に届くまで、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 | ライブラリが全部ここにある。 他を選ぶ理由がほぼ無い |
| 組み込み・OS | C / Rust | メモリを自分で管理できる言語でないと書けない |
| サーバーの道具・CLI | Go / Rust | 実行ファイル1つで配れる。 相手のマシンに何も入れさせない |
| 業務システム(既存) | Java / C# | すでに動いているものが多い。 選ぶというより、そこにある |
表を見て「Pythonのほうがよさそう」と思ったなら、それでいいです。 大事なのは選ぶことではなく、選んだ1つで何かを最後まで作ることです。
結論 — 最初の1つは何でもよい
これは投げやりな結論ではありません。理由があります。
1つ目の言語では、言語の性質と、プログラミング一般の性質の区別がつきません。 変数、条件分岐、ループ、関数、配列。これらは全部の言語にあります。 1つ目を学んでいるとき、あなたは「JavaScript」を学んでいるのではなく、「プログラミング」を学んでいます。
2つ目を学んだときに、初めて「言語の地図」ができます。 「あ、これはどの言語にもある」「これはこの言語だけの都合だ」が、比較して初めて分かるからです。
だから、2つ目に進む価値は「もう1つ書けるようになる」ことではありません。 1つ目で覚えたことのうち、どれが本質でどれが方言だったのかが分かることです。
このサイトでは、2つ目と3つ目を本線でやっています。
同じAPIを3つの言語で書きました。 そこで初めて、「非同期のつらさは JavaScript の都合だった」と分かりました。
後片づけ
立てたものを全部止めます。
残っていないか確認します。
(全部止まっています)
nginx の設定を戻します。
作業ディレクトリを消します。
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回引くだけなら並べると損 — コンピュータ科学深掘り)
- 台数を増やしても頭打ちになった。 この記事です。8倍にして4.53倍。理論値の6.12倍にも届きませんでした
3つとも、頭の中では正しかった判断です。 測って初めて間違いだと分かりました。 だから、このシリーズで一番残しておきたいのはこの1行です。
速くする前に、必ず測る。測る前の判断は、だいたい外れる。
本線に戻ってください。 全体の順路は はじめに にあります。
参考リンク
- roadmap.sh: Computer Science
- Node.js 公式: Worker threads
- Node.js 公式: HTTP モジュール
- nginx 公式: リバースプロキシの設定ガイド
- nginx 公式: HTTP 負荷分散
- MDN: HTTP キャッシュ
- MDN: Cache-Control ヘッダ
- MDN: プロキシサーバーとトンネリング
- man7.org: vmstat(8)
- man7.org: iostat(1)
- man7.org: ss(8)
次に読む
この記事は 【深掘り】コンピュータ科学 の 24 / 25 本目です。
| 記事 | |
|---|---|
| ← 前の記事 | 公開鍵暗号とTLS — 鍵は渡さずに秘密を共有する |
| → 次の記事 | 自作KVストアで理屈を実測する — CSの到達作品 |
上から順に読めば積み上がるように並べています。 飛ばしても構いませんが、詰まったら前の回に戻ってください。
全体の順路は はじめに にあります。
roadmap.sh のどこをやっているか
- アムダールの法則で頭打ちになる
- 状態を持つと台を増やせない
この記事は、上の項目を実際に手を動かして確かめる回です。

コメント