チャットでも、通知でも、株価でも、共同編集でも、いま画面が勝手に更新されるサービスは山ほどあります。
前回: ボトルネックは動く — 負荷分散とキャッシュの設計 作業場所はVMの中(Ubuntu Server)です。
~/serverのAPI、nginx、MySQL、Redis が動いていて、前回アプリを2プロセスにした状態から始めます。 ただし⑥まではmyserver@3000の1つだけで進めるので、最初にsudo systemctl stop myserver@3001で 3001 を止めておいてください(⑥で戻します。nginx は止まった 3001 には繋がらないので、3000 に回します)。
作る側になって最初に困るのが、ここです。
どうやってサーバーから画面に「更新があったよ」と伝えるのか。
そして調べると、だいたいいきなり WebSocket が出てきます。 ライブラリを入れて、数行書いて、動きます。
それだと、何も分かりません。 なぜなら、そもそも何が困っているのかを飛ばしているからです。
この回では、素朴なやり方から順に作ります。2秒ごとに聞き直すところから始めて、その無駄をログの行数で見てから、ロングポーリング、Server-Sent Events、WebSocket へ進みます。
そして、この記事にはハマりどころが2つあります。どちらも手元の環境(nginx が前にいる・プロセスが2つある)だから必ず起きるもので、わざと起こしてから直します。
似たタイトルの記事があります。役割が違います。 この記事はサーバーから送る仕組みの実装を扱います。SSEとWebSocketの使い分け|ポーリングをやめる はどちらを選ぶかの判断と、ポーリングとの比較を扱います。
対象レベル: 中級 / 区分: 必修
この記事でわかること
- HTTPは「聞かれたら答える」形しか持っていないこと。サーバーから勝手に送る手段が仕様として無い
- ポーリングの無駄は「なんとなく多い」ではなく、行数で数えられること。1人あたり1日4万件になる
- WebSocket が常に正解ではないこと。サーバー→ブラウザの一方向でよければ SSE のほうが簡単で、再接続まで勝手にやってくれる
- nginx を前に立てると WebSocket は繋がらないこと。
Upgradeを渡す設定が要る。設定漏れは 404 という顔をして出る - プロセスを2つにすると、更新が半分の人にしか届かなくなること。前回セッションが壊れたのと、まったく同じ形
- 繋ぎっぱなしの接続は必ず切れること。再接続は「繋ぎ直す」だけでは足りず、切れていた間の取り直しが要る
この記事でやること
- ポーリングのページを実際に作り、nginx のアクセスログで無駄なリクエストの本数を数える
- ロングポーリングの出口を足して、
curlが返らずに待つのを見る - Server-Sent Events で、サーバーから一方向に流す
wsを入れて WebSocket にし、nginx で失敗させてから直す- プロセスを2つに戻して壊し、Redis の publish/subscribe で直す。認証と再接続まで入れる
先に知る言葉
この記事で初めて出てくる言葉です。 基本的な言葉は用語集にもまとめてあります。
| 言葉 | 意味 |
|---|---|
| リアルタイム | ここでは「更新が、待たずに画面へ出る」程度の意味。厳密な定義の話ではありません |
| ポーリング | 一定間隔で「変わった?」と聞きに行くやり方。短い間隔で聞くのでショートポーリングとも言う |
| ロングポーリング | 聞きに行って、変化があるまでサーバーが返事を保留するやり方 |
| SSE(Server-Sent Events) | サーバーからブラウザへの一方向の流しっぱなし通信。HTTPのまま使える |
| WebSocket | 双方向の繋ぎっぱなし通信。HTTPで始めて、途中から別のものに切り替わる |
Upgrade | 「このHTTP接続を、別のプロトコルに切り替えたい」と申し込むリクエストヘッダ |
| 101 Switching Protocols | その申し込みが通ったときのステータスコード。200 でも 404 でもない |
| ハートビート | 生きているか確認するために、定期的に送る小さな信号。心拍 |
| publish / subscribe | 投げる側と受け取る側を直結しない配り方。投げた内容が、購読している全員に届く |
| ブロードキャスト | 繋がっている全員に同じものを送ること |
「リアルタイム」という言葉に厳密さを求めないでください。 この記事で作るのは「1秒以内には出る」程度のものです。ミリ秒を保証する話(制御機器など)とは別分野で、必要な道具も違います。
HTTPは「聞かれたら答える」しかできない
まず、なぜ困るのかから始めます。
DNSとHTTPSの回とサーバーとは何かの回でやったとおり、HTTPはこういう形をしています。
ブラウザ ──「GET /api/tasks ください」──> サーバー
ブラウザ <──「はい、これです」────────── サーバー
(ここで会話は終わり。接続も用が済めば閉じる)
サーバーは、聞かれるまで喋りません。 というより、喋る先がありません。
これは実装の都合ではなく、HTTPという決まりごとの形そのものです。 「クライアントが要求し、サーバーが応答する」以外の型を持っていません。サーバーの側から会話を始める文法が無いのです。
ここが出発点です。 リアルタイムの話は全部、「HTTPのこの形をどう回避するか」の工夫です。WebSocket も SSE も、この1点への答えです。
[スクリーンショット: 01_ポーリングとWebSocketの比較.png] (この記事の後半で作る2つのページを、ブラウザで横に並べて撮ってください。左が poll.html、右が live.html です。先に読み進めて、両方作ってから撮ります。)
① ポーリング — 一定間隔で聞き直す
サーバーから送れないなら、こっちから何度も聞けばいい。 一番素朴で、一番よく使われている答えです。
静的なページを置けるようにする
いままで ~/server はJSONを返すだけでした。HTMLも返せるようにします。
app.use(session(...)) のすぐ下に1行足します。
app.use(express.static(__dirname + "/public"));
| 書いたもの | 意味 |
|---|---|
express.static | フォルダの中身を、そのままファイルとして返す組み込みの仕組み |
__dirname | いま動いている app.js が置いてあるフォルダの絶対パス |
__dirnameを使うのには理由があります。"public"とだけ書くと「起動したときのカレントディレクトリ」からの相対になり、systemd から起動したときにファイルが見つからなくなります。絶対パスで書けば、どこから起動しても同じ場所を指します。
ログイン用のページ
これから作るページは全部、ログインしていないと何も出ません(認証の回で requireLogin を挟んだためです)。まずブラウザからログインできるようにします。
<!doctype html>
<html lang="ja">
<head>
<meta charset="utf-8">
<title>ログイン</title>
</head>
<body>
<h1>ログイン</h1>
<form id="f">
<input id="email" type="email" value="me@example.com" required>
<input id="password" type="password" placeholder="パスワード" required>
<button>ログイン</button>
</form>
<p id="msg"></p>
<script>
document.getElementById("f").addEventListener("submit", async (e) => {
e.preventDefault();
const res = await fetch("/api/login", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
email: document.getElementById("email").value,
password: document.getElementById("password").value,
}),
});
document.getElementById("msg").textContent =
res.ok ? "ログインしました" : "失敗しました";
});
</script>
</body>
</html>
パスワードを
value=に書いていません。 練習用でも、HTMLに書いた瞬間に、そのファイルを見た人全員が知ることになります。 メールアドレスだけ入れてあります。
ポーリングするページ
<!doctype html>
<html lang="ja">
<head>
<meta charset="utf-8">
<title>タスク(ポーリング)</title>
</head>
<body>
<h1>タスク(2秒ごとに聞き直す)</h1>
<p>
送ったリクエスト: <b id="count">0</b> 件 /
そのうち中身が変わっていた: <b id="changed">0</b> 件
</p>
<form id="add">
<input id="title" required>
<button>追加</button>
</form>
<ul id="list"></ul>
<script>
const $ = (id) => document.getElementById(id);
let count = 0;
let changed = 0;
let last = "";
async function poll() {
const res = await fetch("/api/tasks");
count += 1;
$("count").textContent = count;
if (!res.ok) {
$("list").textContent = "ログインしてください(/login.html)";
return;
}
const text = await res.text();
if (text !== last) {
last = text;
changed += 1;
$("changed").textContent = changed;
$("list").textContent = "";
for (const task of JSON.parse(text)) {
const li = document.createElement("li");
li.textContent = task.title;
$("list").prepend(li);
}
}
}
$("add").addEventListener("submit", async (e) => {
e.preventDefault();
await fetch("/api/tasks", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ title: $("title").value }),
});
$("title").value = "";
});
poll();
setInterval(poll, 2000);
</script>
</body>
</html>
li.textContent = task.titleにしています。innerHTMLにすると、タスクのタイトルに書いたHTMLがそのまま動きます(DOMの回で触れたXSS)。他人が入れた文字を画面に出す場所では、常にtextContentです。
await res.text()で受けて、文字列のまま前回と比べています。JSON.parseしてからオブジェクトを比べようとすると、{} === {}は常にfalseなので「毎回変わった」ことになります。JavaScriptの回の等価の話がここで効きます。
動かす
ブラウザで開きます。 VMのIPは hostname -I で分かります。
まず http://(VMのIP)/login.html でログインし、そのあと http://(VMのIP)/poll.html を開きます。
タスクを追加すると、最大2秒遅れて一覧に出ます。 動いています。
無駄を数える
「無駄が多い」と言葉で言っても、実感になりません。 監視の回と同じで、数えます。
poll.html のタブを開いたまま、VMのターミナルで打ちます。
1分待って、もう一度打ちます。
1483
1513
差は30です。 タブを1枚開いていただけで、1分で30件飛びました。
| 期間 | タブ1枚あたりのリクエスト |
|---|---|
| 1分 | 30件 |
| 1時間 | 1,800件 |
| 1日 | 43,200件 |
| 100人が開いていたら1日 | 432万件 |
そして、この間にタスクを2個足したなら、意味があったのは2件です。 画面の changed を見てください。43,200件のうち、中身が変わっていたのは数件です。
残りの99.99%は、「変わってません」という答えを運ぶためだけに、 TCP接続 → nginx → Node.js → MySQL → JSON化 → 返却 を全部やっています。 前回測った 1,892 req/s は、これで簡単に埋まります。 100人で 432万件/日 は、平均して秒間50件です。
[スクリーンショット: 02_ポーリングの無駄.png] poll.html の画面で、送ったリクエスト件数が3桁になっていて、変わっていた件数が1桁という状態を撮ってください。この差が、この記事の動機です。
それでもポーリングでよい場合がある
ここで「だからポーリングは駄目」と結論しないでください。
| ポーリングでよい | 理由 |
|---|---|
| 更新が数分に1回で足りる | 間隔を60秒にすれば、1日1,440件。全く問題になりません |
| 開いている人が少ない | 社内ツールで同時5人なら、2秒間隔でも1日20万件。まだ耐えます |
| とにかく単純にしたい | 追加の道具・追加の設定・追加の障害点が、ゼロです |
ポーリングの本当の強みは、「壊れ方が既知であること」です。 ただのHTTPリクエストなので、再接続もキャッシュもプロキシも認証も、いままでの知識がそのまま通用します。 これから先で出てくる方式は、全部この安心を捨てていく話です。
② ロングポーリング — 返事を保留してもらう
間隔を短くすると無駄が増え、長くすると遅くなります。 この板挟みを、「聞きに行くけど、変化があるまで返事を待ってもらう」で抜けるのがロングポーリングです。
ブラウザ ──「GET /api/tasks/wait」──> サーバー
(……何も返さずに保留……)
(タスクが増えた!)
ブラウザ <──「増えました、これです」── サーバー
ブラウザ ──「GET /api/tasks/wait」──> サーバー ← すぐ次を聞きに行く
出口を足す
置く場所が重要です。 app.get("/api/tasks/:id", ...) より上に書いてください。理由は後述します。
// ---- ロングポーリング ----
let waiters = [];
app.get("/api/tasks/wait", requireLogin, (req, res) => {
const waiter = { res, userId: req.session.userId };
waiter.timer = setTimeout(() => {
waiters = waiters.filter((w) => w !== waiter);
res.status(204).end();
}, 25000);
waiters.push(waiter);
req.on("close", () => {
clearTimeout(waiter.timer);
waiters = waiters.filter((w) => w !== waiter);
});
});
function wakeWaiters(userId, task) {
const rest = [];
for (const w of waiters) {
if (w.userId === userId) {
clearTimeout(w.timer);
w.res.json([task]);
} else {
rest.push(w);
}
}
waiters = rest;
}
| 書いたもの | なぜ要るか |
|---|---|
waiters | まだ返事をしていないレスポンスを、配列に貯めておく。 ここが要点 |
25秒の setTimeout | 永久に保留しない。 何も起きなければ 204(中身なし)を返して、いったん終わらせる |
req.on("close") | ブラウザのタブが閉じられたら片づける。 これが無いと、返す先の無い res が溜まり続けます |
w.userId === userId | 自分のタスクの通知だけを受け取る。 認証の回の「認可」が、ここにも要ります |
追加のときに起こす
app.post("/api/tasks", ...) を、こう書き換えます。
app.post("/api/tasks", requireLogin, async (req, res) => {
const title = (req.body.title || "").trim();
if (!title) return res.status(400).json({ error: "title は必須です" });
try {
const [result] = await pool.query(
"INSERT INTO tasks (title, user_id) VALUES (?, ?)",
[title, req.session.userId]
);
const [rows] = await pool.query(
"SELECT id, title, done, created_at FROM tasks WHERE id = ?",
[result.insertId]
);
const task = rows[0];
wakeWaiters(req.session.userId, task);
res.status(201).json(task);
} catch (err) {
console.error(err);
res.status(500).json({ error: "サーバー内部エラー" });
}
});
キャッシュの回でキャッシュ削除の行を足した人は、その行はそのまま残してください。 ここでは
wakeWaitersの1行を足しただけです。
動かす
ターミナルを2つ使います(VS Code なら + で増やせます)。
1つめ。 ログインして、待ちに行きます。
返ってきません。 ここが見どころです。プロンプトが戻らないまま止まっています。
2つめのターミナルで、タスクを足します。
1つめが、その瞬間に返ります。
[{"id":42,"title":"ロングポーリングの実験","done":0,"created_at":"..."}]
real 0m12.418s
12秒間、1件のリクエストで待っていました。 ポーリングなら6回聞いて6回「変わってません」と言われていた時間です。
[スクリーンショット: 03_ロングポーリングが待つ.png] 1つめのターミナルの time の結果(real が数秒以上)と、2つめのターミナルの POST を1枚に収めて撮ってください。
ロングポーリングの弱いところ
| 問題 | 中身 |
|---|---|
| 接続を1本占有する | 待っている間ずっと繋がっている。人数ぶんの接続が居座る |
| 返すたびに繋ぎ直す | 1件届くたびにHTTPのやりとりが1往復。更新が多いと、ポーリングとあまり変わらない |
| 取りこぼす | 返してから次に聞きに行くまでのわずかな隙間に起きた更新は、届きません |
| タイムアウトとの戦い | 25秒にしたのは、nginx の既定が60秒で切るからです。待つ側が、途中の全員のタイムアウトを気にする必要がある |
ロングポーリングは「HTTPしか使えない環境での妥協策」です。 動くし、いまも現役で使われていますが、これを新規に選ぶ理由は、下の2つが使えないときだけです。
③ Server-Sent Events — サーバーから流しっぱなしにする
「1件返したら終わり」が問題なら、返し終わらなければいい。 それが SSE です。
接続を1本開いたまま、サーバーが好きなタイミングで書き足していきます。 ブラウザ側は EventSource という組み込みの機能で受けます。
出口を足す
さっきのロングポーリングの下に足します。
// ---- Server-Sent Events ----
const sseClients = new Set();
app.get("/api/events", requireLogin, (req, res) => {
res.set({
"Content-Type": "text/event-stream",
"Cache-Control": "no-cache",
"Connection": "keep-alive",
"X-Accel-Buffering": "no",
});
res.flushHeaders();
const client = { res, userId: req.session.userId };
sseClients.add(client);
res.write(`event: hello\ndata: ${JSON.stringify({ instance: INSTANCE })}\n\n`);
const beat = setInterval(() => res.write(": ping\n\n"), 25000);
req.on("close", () => {
clearInterval(beat);
sseClients.delete(client);
});
});
function sendSse(payload) {
const text = JSON.stringify(payload);
for (const c of sseClients) {
if (c.userId === payload.userId) {
c.res.write(`event: ${payload.type}\ndata: ${text}\n\n`);
}
}
}
そして app.post("/api/tasks", ...) の wakeWaiters の下に1行足します。
wakeWaiters(req.session.userId, task);
sendSse({ type: "task:created", userId: req.session.userId, task });
SSEの中身は、ただのテキストです。 決まりはこれだけです。
event: task:created
data: {"type":"task:created","task":{"id":42,"title":"..."}}
| 書き方 | 意味 |
|---|---|
event: 行 | イベント名。省略すると message という名前になる |
data: 行 | 中身。1行に収まらないときは data: を複数行書く |
| 空行 | ここで1件おしまい、という区切り。 \n\n を忘れると、永遠に届きません |
: で始まる行 | コメント。 中身は無視されるので、生存確認(ハートビート)に使えます |
X-Accel-Buffering: noが要ります。 nginx は既定で後ろのアプリの応答をいったん溜めてからまとめて返します(そのほうが速いからです)。SSEはこれをやられると、書いたそばから届かず、溜まってから一気に来ます。 このヘッダはnginx への指示で、「この応答は溜めないで」という意味です。アプリ側から1行で言えるので、nginx の設定を触らずに済みます。(設定側でproxy_buffering off;と書いても同じです)
instanceは前回作った環境変数です。 どのプロセスが応えたかを、ここでも出しておきます。後半の山場で効きます。
受け取るページ
<!doctype html>
<html lang="ja">
<head>
<meta charset="utf-8">
<title>タスク(SSE)</title>
</head>
<body>
<h1>タスク(Server-Sent Events)</h1>
<p>接続先プロセス: <b id="instance">?</b> / 状態: <b id="state">未接続</b></p>
<form id="add">
<input id="title" required>
<button>追加</button>
</form>
<ul id="list"></ul>
<script>
const $ = (id) => document.getElementById(id);
function addRow(task) {
if ($("list").querySelector(`[data-id="${task.id}"]`)) return;
const li = document.createElement("li");
li.dataset.id = task.id;
li.textContent = task.title;
$("list").prepend(li);
}
async function load() {
const res = await fetch("/api/tasks");
if (!res.ok) {
$("state").textContent = "ログインしてください(/login.html)";
return;
}
$("list").textContent = "";
for (const task of await res.json()) addRow(task);
}
$("add").addEventListener("submit", async (e) => {
e.preventDefault();
await fetch("/api/tasks", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ title: $("title").value }),
});
$("title").value = "";
});
const es = new EventSource("/api/events");
es.addEventListener("hello", (e) => {
$("state").textContent = "接続中";
$("instance").textContent = JSON.parse(e.data).instance;
load();
});
es.addEventListener("task:created", (e) => {
addRow(JSON.parse(e.data).task);
});
es.addEventListener("error", () => {
$("state").textContent = "切断(自動で繋ぎ直します)";
});
load();
</script>
</body>
</html>
ブラウザを2枚開きます。 片方を別のPCやスマホから開くと、より分かります(同じVMのIPを開くだけです)。
片方でタスクを追加すると、もう片方に即座に出ます。 ポーリングと違って、待ち時間がありません。
ここが分かれ道 — WebSocket は要らないかもしれない
いま作ったもので、この記事の目的は達成しています。
もう一度、最初の問題を思い出してください。 困っていたのは「サーバーから勝手に送れない」でした。SSEは、それを解決しています。
| SSE の良いところ | 中身 |
|---|---|
| ただのHTTP | 認証もCookieもプロキシもキャッシュも、いままでの知識がそのまま通用する |
| 再接続が自動 | 切れたら EventSource が勝手に繋ぎ直します。 コードを1行も書いていません |
| 取りこぼしを減らす仕組みが仕様にある | id: を付けて送ると、再接続時に Last-Event-ID ヘッダで続きから要求してくれる |
サーバー側もただの res.write | 新しいライブラリが要りません |
では、なぜ WebSocket があるのか。 SSEは一方向だからです。
| SSE | WebSocket | |
|---|---|---|
| 向き | サーバー → ブラウザのみ | 双方向 |
| ブラウザ → サーバー | 普通に fetch する(別接続) | 同じ接続で送れる |
「双方向」と聞くと、SSEでは送れないように聞こえますが、違います。 SSEでも、ブラウザからの送信は
fetchで普通にできます(上のページも、追加はfetchでやっています)。問題になるのは、送る回数がとても多いときだけです。
作るもの 向いているほう 通知・タイムライン・進捗表示・株価・ログの流し見 SSE 共同編集・チャット・ゲーム・カーソル共有 WebSocket 迷ったら SSE。 あとで WebSocket に替えるのは難しくありません
この記事では、この先 WebSocket をやります。 ただし理由は「そのほうが良いから」ではなく、双方向の仕組みと、その代償を実際に見るためです。
4つの比べ方
先に表にしておきます。
| ポーリング | ロングポーリング | SSE | WebSocket | |
|---|---|---|---|---|
| 向き | 双方向(毎回HTTP) | 双方向(毎回HTTP) | サーバー→ブラウザのみ | 双方向 |
| 遅れ | 間隔ぶん(数秒〜数分) | ほぼ無し | ほぼ無し | ほぼ無し |
| 無駄なリクエスト | 非常に多い | 少ない | ほぼ無し | ほぼ無し |
| 接続の占有 | 無し | 待っている間ずっと | ずっと | ずっと |
| 正体 | ただのHTTP | ただのHTTP | ただのHTTP | HTTPで始まる別物 |
| 再接続 | 気にしなくてよい | 自分で書く | ブラウザが自動でやる | 自分で書く |
| nginx の追加設定 | 不要 | 不要(タイムアウトに注意) | バッファリングを切る | Upgrade を渡す設定が必須 |
| 認証 | Cookieがそのまま効く | 同左 | 同左 | 繋ぐときだけ確認できる。以降は自前 |
| サーバー側の道具 | 不要 | 不要 | 不要 | ws などのライブラリ |
| 向いているもの | 更新が稀・人が少ない | HTTPしか通らない環境 | 通知・進捗・配信 | チャット・共同編集・ゲーム |
| 向かないもの | 人が多い・速さが要る | 更新が多い | ブラウザからの高頻度送信 | これで足りるものすべて(複雑さが増すだけ) |
一番下の行が、この記事で一番言いたいことです。 WebSocket を選ぶと、この先ずっと「nginx の設定」「再接続の実装」「プロセス間の配送」を自分で面倒みることになります。 上の3つには、その仕事がありません。
④ WebSocket を入れる
HTTPで接続を始めて、途中で「この接続、別のものに切り替えていい?」と聞くのが WebSocket です。
ブラウザ ──「GET /ws Upgrade: websocket」──> サーバー
ブラウザ <──「101 Switching Protocols」────── サーバー
(ここから先はHTTPではない。どちらからでも、いつでも送れる)
101 Switching Protocols が、この記事で初めて見るステータスコードです。200 でも 404 でもなく、「切り替えました」という意味です。
入れる
8.18.3
wsは「WebSocketのサーバー側」を実装したライブラリです。 ブラウザ側には組み込みでWebSocketがあるので、何も入れません。socket.ioという有名なものもありますが、あれは WebSocket ではありません。 WebSocket が使えないときにポーリングへ落ちる独自のプロトコルで、socket.ioのクライアントが要ります。素の WebSocket を知る前に使うと、何が標準で何がライブラリなのか分からなくなります。
書く — まず一番単純な形で
ファイルの一番下、app.listen(...) を丸ごと消して、こう書き換えます。
const PORT = Number(process.env.PORT) || 3000;
const INSTANCE = process.env.INSTANCE || "a";
const http = require("node:http");
const { WebSocketServer } = require("ws");
const server = http.createServer(app);
const wss = new WebSocketServer({ server, path: "/ws" });
wss.on("connection", (ws) => {
ws.on("error", (err) => console.error("[ws]", err.message));
ws.send(JSON.stringify({ type: "hello", instance: INSTANCE }));
});
function sendWs(payload) {
const text = JSON.stringify(payload);
for (const ws of wss.clients) {
if (ws.readyState === 1) ws.send(text);
}
}
server.listen(PORT, "127.0.0.1", () => {
console.log(`instance=${INSTANCE} listening on 127.0.0.1:${PORT}`);
});
app.post("/api/tasks", ...) にも1行足します。
wakeWaiters(req.session.userId, task);
sendSse({ type: "task:created", userId: req.session.userId, task });
sendWs({ type: "task:created", userId: req.session.userId, task });
| 書いたもの | 意味 |
|---|---|
http.createServer(app) | app.listen() が裏でやっていたことを、自分で書いた形。同じHTTPサーバーを WebSocket と共有するために要る |
{ server, path: "/ws" } | そのHTTPサーバーに相乗りして、/ws に来た切り替え要求だけ受ける |
wss.clients | いま繋がっている全員の集合。ws が管理してくれます |
readyState === 1 | 「開いている」という状態。 閉じかけの相手に送ると例外が出ます |
app.listen()を残したままserver.listen()を書くと、EADDRINUSE(そのポートは使用中)で落ちます。 消し忘れです。 実際にやりました。いまの
sendWsは、繋がっている全員に送っています。 つまり他人のタスクが、他人の画面に出ます。 認証の回でせっかくuser_idで絞ったものが、この経路だけ素通りしています。この記事の後半で直します。
受け取るページ
<!doctype html>
<html lang="ja">
<head>
<meta charset="utf-8">
<title>タスク(WebSocket)</title>
</head>
<body>
<h1>タスク(WebSocket)</h1>
<p>接続先プロセス: <b id="instance">?</b> / 状態: <b id="state">未接続</b></p>
<form id="add">
<input id="title" required>
<button>追加</button>
</form>
<ul id="list"></ul>
<script>
const $ = (id) => document.getElementById(id);
function addRow(task) {
if ($("list").querySelector(`[data-id="${task.id}"]`)) return;
const li = document.createElement("li");
li.dataset.id = task.id;
li.textContent = task.title;
$("list").prepend(li);
}
async function load() {
const res = await fetch("/api/tasks");
if (!res.ok) {
$("state").textContent = "ログインしてください(/login.html)";
return;
}
$("list").textContent = "";
for (const task of await res.json()) addRow(task);
}
$("add").addEventListener("submit", async (e) => {
e.preventDefault();
await fetch("/api/tasks", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ title: $("title").value }),
});
$("title").value = "";
});
let retry = 0;
function connect() {
const proto = location.protocol === "https:" ? "wss:" : "ws:";
const ws = new WebSocket(`${proto}//${location.host}/ws`);
ws.addEventListener("open", () => {
$("state").textContent = "接続中";
load(); // 切れていた間の更新を取り直す
retry = 0;
});
ws.addEventListener("message", (e) => {
const msg = JSON.parse(e.data);
if (msg.type === "hello") $("instance").textContent = msg.instance;
if (msg.type === "task:created") addRow(msg.task);
});
ws.addEventListener("close", () => {
const wait = Math.min(1000 * 2 ** retry, 30000);
retry += 1;
$("state").textContent = `切断(${wait / 1000}秒後に再接続)`;
setTimeout(connect, wait);
});
ws.addEventListener("error", () => ws.close());
}
load();
connect();
</script>
</body>
</html>
location.hostから組み立てています。 URLを手で書くと、別のPCから開いた瞬間に繋がりません(localhostはそのPC自身を指すからです)。開いているページと同じホストへ繋ぐ、が正解です。
https:ならwss:にしています。 SSLの回と同じ関係で、https のページからws:(暗号化なし)へは、ブラウザが繋がせてくれません。
⑤ nginx が前にいると繋がらない
ブラウザで http://(VMのIP)/live.html を開きます。
繋がりません。 状態が「切断(1秒後に再接続)」「切断(2秒後に再接続)」と増えていきます。F12 を押してコンソールを見てください(開発者ツールの回)。
WebSocket connection to 'ws://192.168.x.x/ws' failed:
Error during WebSocket handshake: Unexpected response code: 404
404。 ここが一番の落とし穴です。
404 を見た人は、まず「パスを間違えた」と思います。
/wsの綴りを確認して、app.jsを見て、何も間違っていないので途方に暮れます。私はここで30分溶かしました。
切り分ける — nginx を飛ばして直接叩く
障害の回と同じ手順です。「どこまでは正しいか」を確かめます。
まずアプリに直接、手でWebSocketの申し込みをします。
HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=
101 が返りました。アプリは正しい。
Ctrl+Cで抜けてください。101のあとは接続が開きっぱなしになるので、curlは戻りません。
次に、nginx 経由で同じことをします。
HTTP/1.1 404 Not Found
Server: nginx/1.24.0
Content-Type: text/html; charset=utf-8
Content-Length: 141
犯人が確定しました。nginx です。
[スクリーンショット: 04_101と404.png] 直接叩いたときの 101 Switching Protocols と、nginx 経由の 404 Not Found を、同じ画面に並べて撮ってください。この記事で一番撮る価値のある1枚です。
なぜ 404 なのか
nginx は、Upgrade と Connection を後ろに渡しません。
これは nginx のバグではなく、HTTPの決まりです。 この2つは「ホップバイホップヘッダ」と呼ばれ、「隣の相手にだけ意味がある」と定められています。プロキシはこれを次へ転送してはいけません。
その結果、こうなります。
ブラウザ → nginx : GET /ws Upgrade: websocket Connection: Upgrade
nginx → アプリ : GET /ws ← 2つとも消えている
アプリから見ると、ただの GET /ws です。 ws は「切り替えの申し込みではない」と判断して何もせず、Express に処理が渡り、/ws というルートは無いので 404 を返します。
404の意味は「/ws が無い」で合っていたのです。申し込みだと伝わらなかったので、普通のページとして探されただけでした。
直す
nginx に「これは特別扱いしろ」と明示します。
編集後の全文です。
log_format upstreamlog '$remote_addr -> $upstream_addr [$status] $request_time "$request"';
map $http_upgrade $connection_upgrade {
default upgrade;
'' close;
}
upstream app_servers {
server 127.0.0.1:3000;
server 127.0.0.1:3001;
}
server {
listen 80 default_server;
server_name _;
access_log /var/log/nginx/access.log upstreamlog;
location /ws {
proxy_pass http://app_servers;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection $connection_upgrade;
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;
proxy_read_timeout 3600s;
proxy_send_timeout 3600s;
}
location / {
proxy_pass http://app_servers;
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;
}
}
足したのは、上の map と location /ws だけです。
| 書いたもの | なぜ要るか |
|---|---|
map $http_upgrade $connection_upgrade | 「Upgrade ヘッダがあれば Connection: upgrade、無ければ Connection: close」という変数を作る |
proxy_http_version 1.1 | nginx は後ろへ既定で HTTP/1.0 で話します。 1.0 に Upgrade の仕組みはありません。 これが無いと直りません |
proxy_set_header Upgrade | 消えていたヘッダを、明示的に付け直す |
proxy_read_timeout 3600s | 既定は60秒。 繋ぎっぱなしの接続が、1分ごとに切られるのを防ぐ |
なぜ
mapなんて回りくどいことをするのか。proxy_set_header Connection "upgrade";と直に書いてもWebSocketは繋がります。しかし、そうすると/wsに来た普通のHTTPリクエストにまでConnection: upgradeが付きます。mapは「申し込みがあったときだけ upgrade、それ以外は close」を自動で切り替えるための書き方です。nginx公式のWebSocket解説がこの形を載せています。
mapはserver { }の外に書きます。 中に書くと"map" directive is not allowed hereでnginx -tが落ちます。upstreamと同じ理由(前回踏みました)です。
もう一度、nginx 経由で叩きます。
HTTP/1.1 101 Switching Protocols
Upgrade: websocket
通りました。 ブラウザで live.html を開き直すと、「接続中」になります。2枚開いて、片方でタスクを足すと、もう片方に即座に出ます。
戻し方。
sudo cp /etc/nginx/sites-available/default.bak2 /etc/nginx/sites-available/defaultしてsudo nginx -t && sudo systemctl reload nginx。
⑥ プロセスを2つにすると壊れる
ここまで、myserver@3000 の1つだけで動かしてきました。 前回2つにしたのを、戻します。
active
active
ブラウザを2枚開きます。 live.html を2つのタブ(できれば別のブラウザか別の端末)で開いてください。
画面に出ている「接続先プロセス」を見てください。
タブA: 接続先プロセス: 3000
タブB: 接続先プロセス: 3001
片方が 3000、もう片方が 3001 に繋がっています。 nginx がラウンドロビンで振り分けた結果です。
タブAでタスクを足してください。
- タブA: 出ます
- タブB: 出ません
[スクリーンショット: 05_片方に届かない.png] 2つのタブを並べて、接続先プロセスが 3000 と 3001 で違っていて、片方だけタスクが増えている状態を撮ってください。
なぜ壊れたのか
前回と、まったく同じ形です。
タブA ──WebSocket──> プロセス3000 wss.clients = [ タブA ]
タブB ──WebSocket──> プロセス3001 wss.clients = [ タブB ]
タブAが追加 → POSTがどちらかに届く → sendWs はそのプロセスの wss.clients にだけ送る
→ もう片方のプロセスに繋がっている人には、届かない
wss.clientsは、そのプロセスのメモリの中にあります。 前回セッションが壊れたのと、同じ話です。 あのときは「ログイン情報がプロセスのメモリにあった」。今回は「繋がっている人の一覧がプロセスのメモリにある」。どちらも「状態をアプリのプロセスの中に持っている」から壊れました。
しかも今回はもっと厄介です。 セッションのときは「外に出す」で直りました。しかし繋がっている接続そのものは、外に出せません。 ソケットは、そのプロセスが握っているものだからです。
直す方向 — 接続ではなく、お知らせのほうを配る
発想を変えます。
接続を共有するのではなく、「タスクが増えた」という事実を全プロセスに配る。 受け取った各プロセスが、自分の接続にだけ流す。
POST が 3000 に届く
→ 3000 が Redis に「task:created が起きた」と publish
→ 3000 も 3001 も、それを subscribe している
→ それぞれが、自分の wss.clients に流す
→ タブAにもタブBにも届く
これが publish / subscribe(パブサブ)です。 そしてRedisは、これを最初から持っています。(キャッシュの回で入れた、あのRedisです)
先に、コマンドで確かめます。 ターミナルを2つ使います。
1つめ。
2つめ。
1つめに、その瞬間に出ます。
1) "message"
2) "app:v1:events"
3) "{\"hello\":true}"
これだけです。 難しいことは何もありません。
⑦ 全部つなげる — 認証・publish/subscribe・切断
ここで、後回しにしていたものを全部入れます。
- 認証(いまは誰でも
/wsに繋げて、他人のタスクが見えている) - publish / subscribe(プロセスをまたいで届ける)
- 切断の扱い(ハートビート)
まず、セッションを使い回せる形にする
いまの app.js は app.use(session({ ... })) と直接書いてあります。 WebSocketの接続時にも同じものを使いたいので、名前を付けて分けます。
元の app.use(session({...})) を、こう書き換えます。中身は1文字も変えません。
const sessionParser = session({
store,
secret: process.env.SESSION_SECRET,
resave: false,
saveUninitialized: false,
cookie: {
httpOnly: true,
sameSite: "lax",
secure: false,
maxAge: 1000 * 60 * 60 * 24 * 7,
},
});
app.use(sessionParser);
.env に1行足します。
ALLOWED_ORIGINS=http://localhost,http://192.168.x.x
192.168.x.xは、hostname -Iで出た自分のVMのIPに置き換えてください。 ここを間違えると、ブラウザから繋がらなくなります(理由は下のOriginの説明にあります)。
ファイルの末尾を、完成形に置き換える
const PORT = ... から下を、全部これに置き換えます。
const PORT = Number(process.env.PORT) || 3000;
const INSTANCE = process.env.INSTANCE || "a";
const http = require("node:http");
const { WebSocketServer } = require("ws");
const server = http.createServer(app);
const wss = new WebSocketServer({ noServer: true });
const ALLOWED_ORIGINS = (process.env.ALLOWED_ORIGINS || "http://localhost").split(",");
// --- 繋ぎに来た人を、繋ぐ前に確かめる ---
server.on("upgrade", (req, socket, head) => {
const { pathname } = new URL(req.url, "http://localhost");
if (pathname !== "/ws") {
socket.destroy();
return;
}
if (!ALLOWED_ORIGINS.includes(req.headers.origin)) {
socket.write("HTTP/1.1 403 Forbidden\r\n\r\n");
socket.destroy();
return;
}
sessionParser(req, {}, () => {
if (!req.session || !req.session.userId) {
socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
socket.destroy();
return;
}
wss.handleUpgrade(req, socket, head, (ws) => {
ws.userId = req.session.userId;
wss.emit("connection", ws, req);
});
});
});
wss.on("connection", (ws) => {
ws.isAlive = true;
ws.on("pong", () => { ws.isAlive = true; });
ws.on("error", (err) => console.error("[ws]", err.message));
ws.send(JSON.stringify({ type: "hello", instance: INSTANCE }));
});
// --- 死んでいる接続を片づける(ハートビート) ---
const heartbeat = setInterval(() => {
for (const ws of wss.clients) {
if (ws.isAlive === false) {
ws.terminate();
continue;
}
ws.isAlive = false;
ws.ping();
}
}, 30000);
wss.on("close", () => clearInterval(heartbeat));
// --- このプロセスに繋がっている人に配る ---
function deliver(payload) {
const text = JSON.stringify(payload);
for (const ws of wss.clients) {
if (ws.readyState === 1 && ws.userId === payload.userId) ws.send(text);
}
for (const c of sseClients) {
if (c.userId === payload.userId) {
c.res.write(`event: ${payload.type}\ndata: ${text}\n\n`);
}
}
if (payload.task) wakeWaiters(payload.userId, payload.task);
}
// --- 全プロセスに配る ---
const sub = redis.duplicate();
sub.on("error", (err) => console.error("[redis:sub]", err.message));
sub
.connect()
.then(() => sub.subscribe("app:v1:events", (message) => deliver(JSON.parse(message))))
.catch((err) => console.error("[redis:sub] 繋がりません:", err.message));
async function publishEvent(payload) {
try {
await redis.publish("app:v1:events", JSON.stringify(payload));
} catch (err) {
console.error("[redis:pub]", err.message);
deliver(payload); // Redisが駄目でも、せめて自分の分だけは配る
}
}
server.listen(PORT, "127.0.0.1", () => {
console.log(`instance=${INSTANCE} listening on 127.0.0.1:${PORT}`);
});
app.post("/api/tasks", ...) の3行を、1行に戻します。
await publishEvent({ type: "task:created", userId: req.session.userId, task });
さっき足した sendSse(...) と sendWs(...) の行は消し、wakeWaiters(...) の行も消してください(deliver の中から呼ばれるようになったためです)。sendSse と sendWs の関数定義も、もう要りません。
app.js の中身は、上から順にこの並びになります。
1. require と pool と redis
2. sessionParser と app.use(sessionParser)
3. express.static
4. requireLogin
5. /api/register /api/login /api/logout
6. /api/tasks/wait ← ⚠️ /api/tasks/:id より上
7. /api/events(SSE)と sseClients
8. /api/tasks 一式(GET / POST / PUT / PATCH / DELETE)
9. /api/stats /api/health
10. PORT・INSTANCE から下(いま置き換えた塊)
何をしているのか
| 書いたもの | 意味 |
|---|---|
noServer: true | ws に自動で受けさせない。 「繋ぐかどうか、自分で決める」という宣言 |
server.on("upgrade", ...) | 切り替えの申し込みが来たときに呼ばれる。 ここが唯一の関所 |
sessionParser(req, {}, ...) | HTTPのときと同じ仕組みで Cookie を読み、req.session を作る |
ws.userId = ... | この接続が誰のものかを、接続オブジェクトに書いておく。 配るときに使う |
redis.duplicate() | 購読専用の、2本目の接続を作る |
ws.ping() / pong | 生きているか確認する信号。 WebSocketの仕様に組み込みで用意されている |
redis.duplicate()が必要な理由。 Redisは、SUBSCRIBEしたクライアントでは他のコマンドを受け付けません。 そのまま既存のredisで購読すると、キャッシュのGETもSETも全部エラーになります。 必ず別の接続で購読します。
認証について — WebSocket にも Cookie は飛ぶ
ここは誤解が多いところです。
WebSocket の接続は、HTTPリクエストとして始まります。 ということは、Cookie も普通に送られます。 だから、sessionParser にそのまま食わせれば、HTTPのときとまったく同じログイン判定ができます。
ただし、HTTPと同じではない点が3つあります。
| 違い | 中身 |
|---|---|
| 確認できるのは接続の1回だけ | 繋がったあとは、リクエストごとの確認がありません。 ログアウトしても、繋ぎっぱなしの接続は生き続けます |
| ヘッダを自分で足せない | ブラウザの WebSocket はカスタムヘッダを付けられません。 Authorization: Bearer ... が使えないので、Cookieでやるのが自然です |
Origin を自分で見る必要がある | 下に書きます |
Originの確認を省かないでください。 WebSocketの接続は、同一オリジンポリシー(CORS)の対象外です。 他人のサイトに置かれたJavaScriptから、あなたのサイトの WebSocket に、あなたのCookie付きで繋がります。sameSite: "lax"はクロスサイトからの接続には Cookie を付けませんが、同じサイト(兄弟サブドメインなど)からの接続は止めません。 これは Cross-Site WebSocket Hijacking と呼ばれる、実在する攻撃です。 上のコードでreq.headers.originを確かめているのは、そのためです。「繋げるのは、うちのページからだけ」を、サーバー側で明示するしかありません。(セキュリティの回の「自分が開けた穴」の一例です)
そして、ログアウト後の接続を切りたいなら、こう足します。
app.post("/api/logout", (req, res) => {
const userId = req.session.userId;
req.session.destroy(() => {
for (const ws of wss.clients) {
if (ws.userId === userId) ws.close(4001, "logged out");
}
res.status(204).end();
});
});
4001は自分で決めてよいクローズコードです(4000〜4999が自由に使える範囲)。「なぜ切れたか」をクライアントに伝えられます。
切断の扱い
繋ぎっぱなしの接続は、必ず切れます。 相手のPCがスリープした、Wi-Fiが切り替わった、nginx を reload した、途中の機器が黙って捨てた——どれも普通に起きます。
そして一番厄介なのは、「切れたことに気づけない」場合です。
ノートPCの蓋を閉じた
→ TCP接続は「切れました」と誰にも言わない
→ サーバーからは、ただの静かな接続に見える
→ 送っても、エラーにならない。届きもしない
これが「幽霊接続」です。 放っておくと、繋がっているつもりのソケットがメモリに溜まり続けます。
| 対策 | 誰が書くか | 上のコードのどこ |
|---|---|---|
サーバーが定期的に ping する | サーバー | heartbeat の setInterval |
pong が返らなければ切る | サーバー | ws.isAlive === false → terminate() |
| 切れたら繋ぎ直す | ブラウザ | close イベント → setTimeout(connect, ...) |
| 待ち時間を伸ばしていく | ブラウザ | Math.min(1000 * 2 ** retry, 30000) |
| 繋ぎ直したら、取り直す | ブラウザ | open の中の load() |
最後の1行が抜けやすいところです。 切れている間に届いたはずの更新は、二度と来ません。 繋ぎ直しただけの画面は、古いまま「接続中」と表示していることになります。繋がった瞬間に、必ず現状を取り直してください。
待ち時間を伸ばすのも必須です。 失敗のたびに即座に繋ぎ直すコードを書くと、サーバーが落ちた瞬間に、全ブラウザが全力で殴りに来ます。 復旧作業中に、自分の利用者から DoS を受けます。1秒 → 2秒 → 4秒 → と伸ばして、上限で止めます。
動かして、直ったことを確かめる
2つのタブで live.html を開きます。
タブA: 接続先プロセス: 3000
タブB: 接続先プロセス: 3001
タブAでタスクを足すと、タブBにも出ます。 直りました。
Redis 側でも見えます。
1) "app:v1:events"
1) "app:v1:events"
2) (integer) 2
購読しているのが2つ。 アプリのプロセスが2つあるからです。3つに増やせば3になります。
そして、他人のタスクはもう飛びません。 別のユーザーで登録して別のブラウザから開き、片方でタスクを足しても、もう片方には出ないことを確かめてください。
[スクリーンショット: 06_2プロセスでも届く.png] 2つのタブの「接続先プロセス」が 3000 と 3001 で違っていて、両方に同じタスクが出ている状態を撮ってください。05番との対比になります。
Redis の publish/subscribe で足りないこと
動いていますが、これで全部ではありません。
| 弱点 | 中身 |
|---|---|
| 届かなくても分からない | 投げっぱなしです。 購読者が0なら、そのお知らせは消えます |
| 保存されない | 切れていた人の分は残りません。 だから open で取り直しているのです |
| 順番の保証も無い | 複数のプロセスから同時に投げれば、受け取る順は約束されません |
「絶対に落としてはいけないお知らせ」には、これは使えません。 そこから先は保存される仕組みの話になり、別の道具の領域です。
ただし今回のような「画面を新しく見せる」用途では、これで十分です。 落ちても、次に取り直したときに正しくなるからです。この「取り直せば正しくなる」形にしておくのが、実は一番大事な設計です。
つまずいたところ
| 症状 | 原因 |
|---|---|
/api/tasks/wait が 404 | app.get("/api/tasks/:id") より下に書いた。 wait が :id として拾われ、WHERE id = 'wait' で0件 → 404。Express は上から順に照合するので、具体的なパスを先に書く |
EADDRINUSE | app.listen() を消し忘れた。 server.listen() と2つ、同じポートを取りに行っている |
WebSocketが 404 で失敗 | nginx が Upgrade を渡していない。 アプリのパスは正しい。疑う先が違う |
map を足したら nginx -t が落ちる | server { } の中に書いた。 map も upstream も http { } 直下 |
proxy_set_header Upgrade を足したのに直らない | proxy_http_version 1.1; を書いていない。 HTTP/1.0 には Upgrade の仕組みが無い |
| SSEが遅れて、まとめて届く | nginx がバッファリングしている。 X-Accel-Buffering: no か proxy_buffering off; |
| SSEが何も届かない | data: の後ろの空行(\n\n)が無い。 区切りが無いので、1件として完成していない |
| 60秒ちょうどで切れる | proxy_read_timeout の既定が60秒。 SSE側はハートビートで、WS側は設定で伸ばす |
ERR only (P|S)SUBSCRIBE ... allowed | 購読中のクライアントで他のコマンドを打った。 redis.duplicate() で分ける |
403 で繋がらない | ALLOWED_ORIGINS に、いま開いているURLが入っていない。 http://localhost と http://(VMのIP) は別物 |
401 で繋がらない | ログインしていない。 /login.html を先に開く |
| ページが真っ白 | express.static を足していない、または public の場所が違う。ls ~/server/public |
| 片方のタブにだけ出る | プロセスが2つあり、publish/subscribe を入れていない。 この記事の山場② |
1番上と3番目は、どちらも「404」です。 そして原因も直す場所も全く違います。 ステータスコードは症状であって、原因ではありません。 障害の回の「切り分けの順番」——nginx を飛ばして直接叩く——が、ここでも唯一の抜け道でした。
後片づけ
ポーリングのページは、もう要りません。(残しておくと、開いたタブが2秒ごとにリクエストを投げ続けます)
元の1プロセスに戻すなら。
nginx を戻すなら。
WebSocket をやめるなら。
(app.js の末尾を app.listen(PORT, "127.0.0.1", ...) に戻すのを忘れずに)
練習で作ったタスクを消すなら。
Redis のチャンネルは、購読者がいなくなれば自動で消えます。 消す作業はありません。
まとめ
- HTTPは「聞かれたら答える」しかできない。 サーバーから勝手に送る文法が、仕様として無い
- ポーリングの無駄は、数えられる。 2秒間隔なら1人1日43,200件、そのうち意味があるのは数件
- それでも、更新が稀で人が少ないならポーリングでよい。 追加の道具も設定も障害点もゼロ、という強みは大きい
- 一方向でよければ SSE。 ただのHTTPで、再接続はブラウザが勝手にやる。 迷ったらこちら
- WebSocket は双方向の代償を払う選択。 nginx の設定・再接続の実装・プロセス間の配送が、全部自分の仕事になる
- nginx は
Upgradeを後ろに渡さない。 ホップバイホップヘッダだから。proxy_http_version 1.1とmapがセットで要る - 404 は「パスが無い」で合っている。 申し込みが伝わらず、普通のページとして探されただけ
- プロセスを2つにすると壊れる。 前回セッションが壊れたのと同じ形で、状態がプロセスの中にあるから
- 接続は共有できない。 共有するのは「何が起きたか」のほう。それが publish / subscribe
- 繋ぎっぱなしの接続は必ず切れ、しかも気づけない。 ハートビートで掃除し、繋ぎ直したら必ず取り直す
- 再接続の待ち時間は伸ばす。 伸ばさないと、復旧作業中に自分の利用者から殴られる
この記事で足した仕組みは、全部「HTTPの形を回避する工夫」でした。 そして回避するたびに、いままでHTTPが黙ってやってくれていたこと——再接続、認証の毎回確認、プロキシとの相性、負荷分散——を、自分で引き受けることになりました。
これが「リアルタイムにする」の本当のコストです。 動かすだけなら数十行ですが、壊れ方を全部引き取る覚悟が要ります。
参考リンク
- roadmap.sh — Backend Developer
- MDN — WebSocket API
- MDN — サーバー送信イベントの使用
- MDN — EventSource
- RFC 6455 — The WebSocket Protocol
- HTML Standard — Server-sent events
- ws(GitHub)
- ws — express-session と組み合わせる公式サンプル
- nginx — WebSocket proxying
- nginx — ngx_http_map_module
- Redis — Pub/Sub
- node-redis — Pub/Sub
- Express — express.static
次に読む
この記事は 【第8段階】深掘り の 2 / 30 本目です。
| 記事 | |
|---|---|
| ← 前の記事 | ボトルネックは動く — 負荷分散とキャッシュの設計 |
| → 次の記事 | 安全にはできない、被害を小さくする — セキュリティ点検 |
上から順に読めば積み上がるように並べています。 飛ばしても構いませんが、詰まったら前の回に戻ってください。
全体の順路は はじめに にあります。
roadmap.sh のどこをやっているか
- Short Polling
- Long Polling
- Server Sent Events
- WebSockets
この記事は、上の項目を実際に手を動かして確かめる回です。

コメント