サーバーから勝手には送れない — WebSocketとSSE

WebSocketとSSE。ブラウザとサーバー、行き来するメッセージの吹き出し。

チャットでも、通知でも、株価でも、共同編集でも、いま画面が勝手に更新されるサービスは山ほどあります。

前回: ボトルネックは動く — 負荷分散とキャッシュの設計 作業場所は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つにすると、更新が半分の人にしか届かなくなること。前回セッションが壊れたのと、まったく同じ形
  • 繋ぎっぱなしの接続は必ず切れること。再接続は「繋ぎ直す」だけでは足りず、切れていた間の取り直しが要る

この記事でやること

  1. ポーリングのページを実際に作り、nginx のアクセスログで無駄なリクエストの本数を数える
  2. ロングポーリングの出口を足して、curl が返らずに待つのを見る
  3. Server-Sent Events で、サーバーから一方向に流す
  4. ws を入れて WebSocket にし、nginx で失敗させてから直す
  5. プロセスを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も返せるようにします。

bash
$ mkdir -p ~/server/public
$ nano ~/server/app.js

app.use(session(...)) のすぐ下に1行足します。

app.use(express.static(__dirname + "/public"));
書いたもの意味
express.staticフォルダの中身を、そのままファイルとして返す組み込みの仕組み
__dirnameいま動いている app.js が置いてあるフォルダの絶対パス

__dirname を使うのには理由があります。 "public" とだけ書くと「起動したときのカレントディレクトリ」からの相対になり、systemd から起動したときにファイルが見つからなくなります。絶対パスで書けば、どこから起動しても同じ場所を指します。

ログイン用のページ

これから作るページは全部、ログインしていないと何も出ません(認証の回で requireLogin を挟んだためです)。まずブラウザからログインできるようにします。

bash
$ nano ~/server/public/login.html
<!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に書いた瞬間に、そのファイルを見た人全員が知ることになります。 メールアドレスだけ入れてあります。

ポーリングするページ

bash
$ nano ~/server/public/poll.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の回の等価の話がここで効きます。

動かす

bash
$ sudo systemctl restart myserver@3000

ブラウザで開きます。 VMのIPは hostname -I で分かります。

bash
$ hostname -I

まず http://(VMのIP)/login.html でログインし、そのあと http://(VMのIP)/poll.html を開きます。

タスクを追加すると、最大2秒遅れて一覧に出ます。 動いています。

無駄を数える

「無駄が多い」と言葉で言っても、実感になりません。 監視の回と同じで、数えます。

poll.html のタブを開いたまま、VMのターミナルで打ちます。

bash
$ sudo grep -c 'GET /api/tasks ' /var/log/nginx/access.log

1分待って、もう一度打ちます。

bash
$ sudo grep -c 'GET /api/tasks ' /var/log/nginx/access.log
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」──> サーバー   ← すぐ次を聞きに行く

出口を足す

bash
$ nano ~/server/app.js

置く場所が重要です。 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行を足しただけです。

動かす

bash
$ sudo systemctl restart myserver@3000

ターミナルを2つ使います(VS Code なら + で増やせます)。

1つめ。 ログインして、待ちに行きます。

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

$ time curl -s -b c.txt http://localhost/api/tasks/wait

返ってきません。 ここが見どころです。プロンプトが戻らないまま止まっています。

2つめのターミナルで、タスクを足します。

bash
$ cd ~/server
$ curl -s -b c.txt -X POST http://localhost/api/tasks \
    -H "Content-Type: application/json" \
    -d '{"title":"ロングポーリングの実験"}' > /dev/null

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 という組み込みの機能で受けます。

出口を足す

bash
$ nano ~/server/app.js

さっきのロングポーリングの下に足します。

// ---- 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 は前回作った環境変数です。 どのプロセスが応えたかを、ここでも出しておきます。後半の山場で効きます。

受け取るページ

bash
$ nano ~/server/public/sse.html
<!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>
bash
$ sudo systemctl restart myserver@3000

ブラウザを2枚開きます。 片方を別のPCやスマホから開くと、より分かります(同じVMのIPを開くだけです)。

片方でタスクを追加すると、もう片方に即座に出ます。 ポーリングと違って、待ち時間がありません。

ここが分かれ道 — WebSocket は要らないかもしれない

いま作ったもので、この記事の目的は達成しています。

もう一度、最初の問題を思い出してください。 困っていたのは「サーバーから勝手に送れない」でした。SSEは、それを解決しています。

SSE の良いところ中身
ただのHTTP認証もCookieもプロキシもキャッシュも、いままでの知識がそのまま通用する
再接続が自動切れたら EventSource が勝手に繋ぎ直します。 コードを1行も書いていません
取りこぼしを減らす仕組みが仕様にあるid: を付けて送ると、再接続時に Last-Event-ID ヘッダで続きから要求してくれる
サーバー側もただの res.write新しいライブラリが要りません

では、なぜ WebSocket があるのか。 SSEは一方向だからです。

SSEWebSocket
向きサーバー → ブラウザのみ双方向
ブラウザ → サーバー普通に fetch する(別接続)同じ接続で送れる

「双方向」と聞くと、SSEでは送れないように聞こえますが、違います。 SSEでも、ブラウザからの送信は fetch で普通にできます(上のページも、追加は fetch でやっています)。問題になるのは、送る回数がとても多いときだけです。

作るもの向いているほう
通知・タイムライン・進捗表示・株価・ログの流し見SSE
共同編集・チャット・ゲーム・カーソル共有WebSocket
迷ったらSSE。 あとで WebSocket に替えるのは難しくありません

この記事では、この先 WebSocket をやります。 ただし理由は「そのほうが良いから」ではなく、双方向の仕組みと、その代償を実際に見るためです。

4つの比べ方

先に表にしておきます。

ポーリングロングポーリングSSEWebSocket
向き双方向(毎回HTTP)双方向(毎回HTTP)サーバー→ブラウザのみ双方向
遅れ間隔ぶん(数秒〜数分)ほぼ無しほぼ無しほぼ無し
無駄なリクエスト非常に多い少ないほぼ無しほぼ無し
接続の占有無し待っている間ずっとずっとずっと
正体ただのHTTPただのHTTPただのHTTPHTTPで始まる別物
再接続気にしなくてよい自分で書くブラウザが自動でやる自分で書く
nginx の追加設定不要不要(タイムアウトに注意)バッファリングを切るUpgrade を渡す設定が必須
認証Cookieがそのまま効く同左同左繋ぐときだけ確認できる。以降は自前
サーバー側の道具不要不要不要ws などのライブラリ
向いているもの更新が稀・人が少ないHTTPしか通らない環境通知・進捗・配信チャット・共同編集・ゲーム
向かないもの人が多い・速さが要る更新が多いブラウザからの高頻度送信これで足りるものすべて(複雑さが増すだけ)

一番下の行が、この記事で一番言いたいことです。 WebSocket を選ぶと、この先ずっと「nginx の設定」「再接続の実装」「プロセス間の配送」を自分で面倒みることになります。 上の3つには、その仕事がありません。

④ WebSocket を入れる

HTTPで接続を始めて、途中で「この接続、別のものに切り替えていい?」と聞くのが WebSocket です。

ブラウザ ──「GET /ws  Upgrade: websocket」──> サーバー
ブラウザ <──「101 Switching Protocols」────── サーバー
(ここから先はHTTPではない。どちらからでも、いつでも送れる)

101 Switching Protocols が、この記事で初めて見るステータスコードです。200 でも 404 でもなく、「切り替えました」という意味です。

入れる

bash
$ cd ~/server
$ npm install ws
bash
$ node -e "console.log(require('ws/package.json').version)"
8.18.3

ws は「WebSocketのサーバー側」を実装したライブラリです。 ブラウザ側には組み込みで WebSocket があるので、何も入れません。 socket.io という有名なものもありますが、あれは WebSocket ではありません。 WebSocket が使えないときにポーリングへ落ちる独自のプロトコルで、socket.io のクライアントが要ります。素の WebSocket を知る前に使うと、何が標準で何がライブラリなのか分からなくなります。

書く — まず一番単純な形で

bash
$ nano ~/server/app.js

ファイルの一番下、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 で絞ったものが、この経路だけ素通りしています。この記事の後半で直します。

受け取るページ

bash
$ nano ~/server/public/live.html
<!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 が前にいると繋がらない

bash
$ sudo systemctl restart myserver@3000

ブラウザで 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の申し込みをします。

bash
$ curl -i -s -N \
    -H "Connection: Upgrade" \
    -H "Upgrade: websocket" \
    -H "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==" \
    -H "Sec-WebSocket-Version: 13" \
    http://127.0.0.1:3000/ws | head -4
HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=

101 が返りました。アプリは正しい。

Ctrl+C で抜けてください。 101 のあとは接続が開きっぱなしになるので、curl は戻りません。

次に、nginx 経由で同じことをします。

bash
$ curl -i -s -N \
    -H "Connection: Upgrade" \
    -H "Upgrade: websocket" \
    -H "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==" \
    -H "Sec-WebSocket-Version: 13" \
    http://localhost/ws | head -4
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 に「これは特別扱いしろ」と明示します。

bash
$ sudo cp /etc/nginx/sites-available/default /etc/nginx/sites-available/default.bak2
$ sudo nano /etc/nginx/sites-available/default

編集後の全文です。

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.1nginx は後ろへ既定で 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 と同じ理由(前回踏みました)です。

bash
$ sudo nginx -t
$ sudo systemctl reload nginx

もう一度、nginx 経由で叩きます。

bash
$ curl -i -s -N \
    -H "Connection: Upgrade" \
    -H "Upgrade: websocket" \
    -H "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==" \
    -H "Sec-WebSocket-Version: 13" \
    http://localhost/ws | head -2
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つにしたのを、戻します。

bash
$ sudo systemctl restart myserver@3001
$ systemctl is-active myserver@3000 myserver@3001
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つめ。

bash
$ redis-cli --no-auth-warning -a 'パスワード' SUBSCRIBE app:v1:events

2つめ。

bash
$ redis-cli --no-auth-warning -a 'パスワード' PUBLISH app:v1:events '{"hello":true}'

1つめに、その瞬間に出ます。

1) "message"
2) "app:v1:events"
3) "{\"hello\":true}"

これだけです。 難しいことは何もありません。

⑦ 全部つなげる — 認証・publish/subscribe・切断

ここで、後回しにしていたものを全部入れます。

  1. 認証(いまは誰でも /ws に繋げて、他人のタスクが見えている)
  2. publish / subscribe(プロセスをまたいで届ける)
  3. 切断の扱い(ハートビート)

まず、セッションを使い回せる形にする

いまの app.js は app.use(session({ ... })) と直接書いてあります。 WebSocketの接続時にも同じものを使いたいので、名前を付けて分けます。

bash
$ nano ~/server/app.js

元の 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行足します。

bash
$ nano ~/server/.env
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: truews に自動で受けさせない。 「繋ぐかどうか、自分で決める」という宣言
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秒 → と伸ばして、上限で止めます。

動かして、直ったことを確かめる

bash
$ sudo systemctl restart myserver@3000 myserver@3001

2つのタブで live.html を開きます。

タブA:  接続先プロセス: 3000
タブB:  接続先プロセス: 3001

タブAでタスクを足すと、タブBにも出ます。 直りました。

Redis 側でも見えます。

bash
$ redis-cli --no-auth-warning -a 'パスワード' PUBSUB CHANNELS
1) "app:v1:events"
bash
$ redis-cli --no-auth-warning -a 'パスワード' PUBSUB NUMSUB 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 が 404app.get("/api/tasks/:id") より下に書いた。 wait が :id として拾われ、WHERE id = 'wait' で0件 → 404。Express は上から順に照合するので、具体的なパスを先に書く
EADDRINUSEapp.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秒ごとにリクエストを投げ続けます)

bash
$ rm ~/server/public/poll.html

元の1プロセスに戻すなら。

bash
$ sudo systemctl disable --now myserver@3001

nginx を戻すなら。

bash
$ sudo cp /etc/nginx/sites-available/default.bak2 /etc/nginx/sites-available/default
$ sudo nginx -t && sudo systemctl reload nginx

WebSocket をやめるなら。

bash
$ cd ~/server
$ npm uninstall ws

(app.js の末尾を app.listen(PORT, "127.0.0.1", ...) に戻すのを忘れずに)

練習で作ったタスクを消すなら。

bash
$ mysql -u appuser -p appdb -e "DELETE FROM tasks WHERE title LIKE '%実験%';"

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が黙ってやってくれていたこと——再接続、認証の毎回確認、プロキシとの相性、負荷分散——を、自分で引き受けることになりました。

これが「リアルタイムにする」の本当のコストです。 動かすだけなら数十行ですが、壊れ方を全部引き取る覚悟が要ります。

参考リンク


次に読む

この記事は 【第8段階】深掘り の 2 / 30 本目です。

記事
← 前の記事ボトルネックは動く — 負荷分散とキャッシュの設計
→ 次の記事安全にはできない、被害を小さくする — セキュリティ点検

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

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

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

Backend›Real-Time Data
  • Short Polling
  • Long Polling
  • Server Sent Events
  • WebSockets

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

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

コメント

コメントする

目次