SSEとWebSocket — 1秒ごとに聞きに行くのをやめる

SSEとWebSocket。通知が届くブラウザとサーバー、通信の封筒。

1秒ごとに聞きに行くのをやめられます。SSEとWebSocketを両方書いて、使い分けを決めます。

前回: トランザクションとACID — ROLLBACKしたのに戻らない

これは【深掘り】の記事です。本線の順路ではありません。 このシリーズは言葉を覚える回にしません。 全部、手元で書いて、走らせて、数字を出します。 飛ばしても本線は進めます。 本線側の「サーバーから勝手には送れない」話は サーバーから勝手には送れない — WebSocketとSSE にあります。 この記事は、その一段下――WebSocket や SSE が乗っている「ソケット」そのものを掘ります。

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

この記事で立てるサーバーは、全部 127.0.0.1(自分自身)だけで待ち受けます。 外に開きません。他人のサーバーに繋ぐ話は一切しません。 全部、自分のVMの中で完結します。


「新着があったら画面に出したい」だけでした。

作っていたのは、ただの掲示板です。誰かが書き込んだら、他の人の画面にも出てほしい。それだけでした。

私が最初に書いたのはこれです。

setInterval(async () => {
  const r = await fetch('/messages');
  render(await r.json());
}, 1000);

動きました。 1秒以内に出ます。満足しました。

そのあと、サーバーのアクセスログを見ました。

同時に開いていたのは、自分のブラウザ2枚だけです。それなのに1分で120行ログが増えていました。 そして、そのうち書き込みがあったのは2行だけでした。

残りの118回は、「何もありません」と答えるためだけに飛んだリクエストでした。 人が10人になれば600回。100人なら6000回。中身は全部「無し」です。

「じゃあ WebSocket にすればいいのか」と思って調べました。そこで詰まりました。

記事はどれも new WebSocket(...) から始まります。その WebSocket が何の上に乗っているのかが分かりません。 ws:// は HTTP なのか、違うのか。なぜ「アップグレード」という言葉が出てくるのか。 そして SSE というもう1つの選択肢が、なぜ「ただのHTTP」と言われるのか。

全部、1つ下の層を見ないと分かりませんでした。

HTTP も WebSocket も SSE も、全部「ソケット」という同じ1本の管の上に乗っています。 ソケットは1本の電話線です。 繋がっている間だけ、両方向にバイトが流れる。それだけです。 そして電話線には「ここまでが1つの言葉です」という区切りがありません。

この記事では、その電話線を素で1本引きます。 Node.js の net で、HTTP も何も使わずに。 そして、区切りが無いせいで壊れるところを実際に起こして、直します。

そのあとで初めて、ポーリング・ロングポーリング・SSE・WebSocket を、全部自分で書いて、数字で比べます。

似たタイトルの記事があります。役割が違います。 この記事は選び方と比較を扱います。サーバーから勝手には送れない — WebSocketとSSE は実際に実装して動かす手順を扱います。

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

目次

この記事でわかること

  • OSI参照モデルの7層は暗記するものではない。見るのは「自分が書いているコードはどの層か」の1点だけ
  • 実際に動いているのは TCP/IP の4層。7層は「話をするための地図」で、実装ではない
  • TCP はストリーム。メッセージの区切りが無い。だから 200回 write しても data は17回しか起きない
  • 区切りは自分で決める。 改行区切りか、長さプレフィックスか。改行区切りは中身に改行が入ると壊れる
  • UDP は「届く保証も順番の保証も無い」代わりに、メッセージの区切りは保つ。TCP と逆
  • ショートポーリングは、60秒で59回投げて53回が空振り(89.8%が無駄)
  • ロングポーリングは同じ60秒で7回に減る。代償はサーバーが接続を持ち続けること
  • SSE は「ただの text/event-stream な HTTP レスポンス」。curl で全部読める。再接続はブラウザが勝手にやる
  • WebSocket は HTTP でハンドシェイクしてから、プロトコルを乗り換える。101 Switching Protocols がその瞬間
  • 結論は3行で言える。 通知だけなら SSE。双方向が要るときだけ WebSocket。1分に1回でよいならポーリングで十分

この記事でやること

  1. curl を1回打って、その1回で何層が動いたかを上から下まで表にする
  2. Node.js の net で 素のTCPサーバーとクライアントを書き、ss と nc で外から確かめる
  3. 200回 write して data が17回しか起きないところを再現し、改行区切りと長さプレフィックスの両方で直す
  4. dgram で UDP版を書き、わざとパケットを落としてTCPとの違いを数字で見る
  5. ショートポーリングを実装して、60秒間の空振り率を実測する
  6. ロングポーリングを実装して、リクエスト数がどれだけ減るかと、代わりに何が増えるかを測る
  7. SSE の生バイト列を curl -N で見て、WebSocket の 101 を curl -i で取り、フレームを1つ手で解読する
  8. 4つを判断表にして、どれをいつ使うか決める

先に知る言葉

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

言葉意味
ソケット通信の口。「IPアドレス + ポート番号」の組で1つの端。繋がると1本の管になる
TCP届いたことを確認しながら送る方式。順番も保証する。代わりに遅い
UDP投げっぱなしの方式。届いたか確認しない。代わりに軽い
ストリーム切れ目のないバイトの流れ。TCP はこれ。「1件」「2件」という単位が無い
データグラム1個で完結する小包。UDP はこれ。区切りは保たれるが、届く保証は無い
フレーミングストリームの中に「ここまでが1件」の印を自分で入れること
ポーリングこちらから定期的に「変わりましたか」と聞きに行くこと
ロングポーリング聞きに行って、変化があるまでサーバーが返事を保留するやり方
SSEServer-Sent Events。サーバー→ブラウザの一方通行。中身はただのHTTPレスポンス
WebSocketHTTPで挨拶してから乗り換える、双方向の通信路

① 通信は7層に分かれている(が、実際は4層)

最初に断っておきます。OSI参照モデルの7層は、暗記しても何も解決しません。

私も一度、7つの層の名前を語呂合わせで覚えました。現場で1回も使いませんでした。 使ったのは、「いま自分が困っているのはどの層か」を切り分けるときだけです。

7層と4層の対応

OSI の7層は「話をするための地図」で、実装ではありません。 実際に動いているのは TCP/IP の4層です。この2つを1枚の表にします。

OSI(7層・地図)TCP/IP(4層・実物)ここで動くもの自分が書くコードとの関係
第7層 アプリケーションアプリケーション層HTTP, DNS, SSH, WebSocket, SSE普段書いているコードはほぼ全部ここ
第6層 プレゼンテーション同上(分かれていない)TLS, 文字コード, 圧縮HTTPS の「S」の部分
第5層 セッション同上(分かれていない)接続の張り直し, CookieTCP/IP では独立した層が無い
第4層 トランスポートトランスポート層TCP, UDPこの記事の②〜④はここを直接触る
第3層 ネットワークインターネット層IP, ルーティング, ICMPping が届かないときはここ
第2層 データリンクリンク層Ethernet, MACアドレス, ARP同じLAN内の話
第1層 物理同上(分かれていない)ケーブル, 電波, 光LANケーブルが抜けているのもここ

覚えるのはこの1行だけで足ります。

第4層(TCP/UDP)が「どこへ運ぶか」を決め、第7層(HTTP など)が「何を言うか」を決める。 その境目にあるのがソケット。 この記事はずっとその境目にいます。

本線側では、この層の違いがロードバランサーの選び方に直結する話をしています。 L4とL7の違いは中身を見るか — OSI参照モデル を先に読んでも構いません。

curl 1回で、どの層が何をしたか

言葉だけだと分かりません。実際に1回打って、層ごとに時間を出します。

作業フォルダを作ります。

bash
$ mkdir -p ~/cslab/rt
$ cd ~/cslab/rt
$ pwd
/home/user/cslab/rt

curl には「どの段階まで何秒かかったか」を出す機能があります。

bash
$ curl -s -o /dev/null -w 'dns:      %{time_namelookup}\ntcp:      %{time_connect}\ntls:      %{time_appconnect}\nrequest:  %{time_pretransfer}\nfirstbyte:%{time_starttransfer}\ntotal:    %{time_total}\nip:       %{remote_ip}\nport:     %{remote_port}\nhttp:     %{http_version}\ncode:     %{response_code}\n' https://obmes.com/
dns:      0.007089
tcp:      0.030142
tls:      0.066186
request:  0.066418
firstbyte:0.191164
total:    0.211749
ip:       183.181.97.30
port:     443
http:     1.1
code:     200

この数字は「累計」です。 差を取ると、どの層に何秒かかったかが出ます。

順番何が起きたか層かかった時間失敗するとどう見えるか
1obmes.com → 183.181.97.30 に変換第7層(DNS)7.1msCould not resolve host
2相手の 443番ポートまでの経路を通る第3層(IP)(2に含まれる)応答が返らずタイムアウト
3TCPの3ウェイハンドシェイク第4層(TCP)30.1 − 7.1 = 23.0msConnection refused
4TLSハンドシェイク(証明書の確認と鍵の合意)第6層(TLS)66.2 − 30.1 = 36.0mscertificate verify failed
5GET / HTTP/1.1 を送って最初の1バイトが返る第7層(HTTP)191.2 − 66.4 = 124.7ms404 / 500
6本文を全部受け取る第7層211.7 − 191.2 = 20.6ms途中で切れる

ここが一番大事な読み方です。

「サイトが重い」と言われたとき、見るのはこの6行のどこが太っているかです。 – DNS が遅い → DNSサーバーの問題。アプリのコードを直しても直らない – TCP が遅い → 距離か経路の問題。サーバーを近くに置く以外に手が無い – TLS が遅い → 証明書チェーンか、接続を毎回張り直している – firstbyte が遅い → ここで初めてアプリのコードの話になる

私は昔、DNSが遅かっただけの案件で、丸2日アプリのSQLを見ていました。 層で切ってから中に入る。 この順番を守らないと、いくらでも時間が溶けます。

ドメインとHTTPSそのものの話は DNSとHTTPSを自分のドメインで確かめる — 未経験の1歩目 にあります。

📸 スクリーンショット1: 上の curl -w の出力。dns tcp tls firstbyte の4つの数字が並んでいるところを残す


② ソケットを素で書く — HTTPもWebSocketも全部この上に乗っている

ここから、第4層を直接触ります。HTTP は使いません。

Node.js の net モジュールは、TCPのソケットをそのまま扱えます。

bash
$ cat > echo-server.mjs <<'EOF'
  import net from 'node:net';
  
  const server = net.createServer((sock) => {
    const who = `${sock.remoteAddress}:${sock.remotePort}`;
    console.log(`[接続] ${who}`);
  
    sock.on('data', (buf) => {
      console.log(`[受信] ${buf.length} バイト: ${JSON.stringify(buf.toString())}`);
      sock.write(buf);
    });
  
    sock.on('end',   () => console.log(`[切断] ${who}`));
    sock.on('error', (e) => console.log(`[エラー] ${who} ${e.code}`));
  });
  
  server.listen(9001, '127.0.0.1', () => {
    console.log('listen 127.0.0.1:9001');
  });
  EOF

これで全部です。 HTTP のヘッダも、ルーティングも、ステータスコードもありません。 「繋がったらバイトが流れてくる。そのまま返す」だけです。

'127.0.0.1' を必ず書いてください。 省略すると全部のネットワークで待ち受けます。 学習用のVMを外に開く理由はありません。

動かします。別のターミナルをもう1枚開いてください(VS Code から繋いでいるなら、下のターミナルを + で増やせます)。

bash
$ node echo-server.mjs
listen 127.0.0.1:9001

本当に待ち受けているか、外から確かめる

「動いているつもり」が一番危ないので、必ず別の道具で確認します。

もう1枚のターミナルで打ちます。

bash
$ ss -tlnp | head -5
State   Recv-Q  Send-Q  Local Address:Port   Peer Address:Port  Process
LISTEN  0       511         127.0.0.1:9001        0.0.0.0:*      users:(("node",pid=3184,fd=21))

オプションの意味です。

オプション意味
-tTCP だけ表示する
-l待ち受けている(LISTEN)ものだけ
-n番号のまま出す(http ではなく 80)
-pどのプロセスかを出す(sudo が要ることがある)

Local Address が 127.0.0.1:9001 になっていることを確認してください。 ここが 0.0.0.0:9001 だったら、VMの外からも届く状態です。すぐ止めてください。

ネットワークの切り分けそのものは 「繋がらない」を4段階で切り分ける — Linuxのネットワーク にまとめてあります。

nc で手打ちして繋ぐ

ソケットは「1本の電話線」です。手で喋れます。

nc(netcat)は、キーボードで打った文字をそのままソケットに流す道具です。

bash
$ which nc || sudo apt install -y netcat-openbsd
/usr/bin/nc

繋ぎます。

bash
$ nc 127.0.0.1 9001

何も出ません。プロンプトも返りません。 これが正常です。 電話が繋がって、無言でいる状態です。

hello と打って Enter を押します。

hello
hello

2行目は自分が打ったものではありません。 サーバーが返してきたものです。 Ctrl+C で切ります。

サーバー側のターミナルを見ます。

listen 127.0.0.1:9001
[接続] 127.0.0.1:63702
[受信] 6 バイト: "hello\n"
[切断] 127.0.0.1:63702

6 バイト です。 hello は5文字なので、Enter で入った改行が1バイト混ざっています。 nc は改行も込みで送ります。この「1バイト」が、③で全部の原因になります。

コードから繋ぐ

nc と同じことをコードで書きます。

bash
$ cat > echo-client.mjs <<'EOF'
  import net from 'node:net';
  
  const sock = net.connect(9001, '127.0.0.1', () => {
    console.log('つながった');
    sock.write('hello\n');
  });
  
  sock.on('data', (buf) => {
    console.log(`返ってきた: ${JSON.stringify(buf.toString())}`);
    sock.end();
  });
  
  sock.on('close', () => console.log('閉じた'));
  EOF
$ node echo-client.mjs
つながった
返ってきた: "hello\n"
閉じた

サーバー側です。

[接続] 127.0.0.1:63702
[受信] 6 バイト: "hello\n"
[切断] 127.0.0.1:63702

nc で打ったときと、1バイトも変わりません。

これが一番言いたいことです。 HTTP も WebSocket も SSE も、この sock.write() の上に乗っている「決めごと」でしかありません。 HTTP は「最初に GET / HTTP/1.1\r\n と書く」という決めごと。 WebSocket は「HTTPで挨拶してから、独自の形のバイト列を流す」という決めごと。 管そのものは、いま書いたこれと同じです。

「サーバーとは待ち続けるプログラムである」という話は サーバーとは待ち続けるプログラム — 手で書いて確かめる にあります。

サーバーは Ctrl+C で止めておきます。


③ TCPはストリーム。メッセージの区切りが無い

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

私は長いこと、こう思っていました。

❌ 「write を1回呼んだら、相手側で data が1回起きる」

違います。 そして、ローカルで少ないデータを試している間は、たまたま合ってしまいます。 本番で件数が増えた瞬間に壊れます。 私はそれで、チャットの投稿がJSONのパースエラーで消えるバグを出しました。

実際に壊す

200回 write します。 受け取る側は「1回の data = 1件」だと思い込んで数えます。

bash
$ cat > naive-server.mjs <<'EOF'
  import net from 'node:net';
  
  let events = 0;
  let messages = 0;
  
  const server = net.createServer((sock) => {
    sock.on('data', (buf) => {
      events++;
      const s = buf.toString();
      // 「1回の data = 1件のメッセージ」だと思い込んで数える
      messages++;
      if (events <= 3) {
        console.log(`data #${events}: ${buf.length}バイト ${JSON.stringify(s.slice(0, 60))}${s.length > 60 ? '…' : ''}`);
      }
    });
    sock.on('end', () => {
      console.log('---');
      console.log(`data イベントの回数: ${events}`);
      console.log(`受け取ったと思った件数: ${messages}`);
      server.close();
    });
  });
  
  server.listen(9002, '127.0.0.1', () => console.log('listen 127.0.0.1:9002'));
  EOF

$ cat > naive-client.mjs <<'EOF'
  import net from 'node:net';
  
  const N = 200;
  const sock = net.connect(9002, '127.0.0.1', () => {
    for (let i = 1; i <= N; i++) {
      sock.write(JSON.stringify({ n: i }) + '\n');   // write は 200 回
    }
    console.log(`write を ${N} 回呼んだ`);
    sock.end();
  });
  EOF

サーバーを起こしてから、クライアントを走らせます。

bash
$ node naive-server.mjs &
$ sleep 1
$ node naive-client.mjs
listen 127.0.0.1:9002
write を 200 回呼んだ
data #1: 342バイト "{\"n\":1}\n{\"n\":2}\n{\"n\":3}\n{\"n\":4}\n{\"n\":5}\n{\"n\":6}\n{\"n\":7}\n{\"n\""…
data #2: 396バイト "{\"n\":40}\n{\"n\":41}\n{\"n\":42}\n{\"n\":43}\n{\"n\":44}\n{\"n\":45}\n{\"n\":4"…
data #3: 174バイト "{\"n\":84}\n{\"n\":85}\n{\"n\":86}\n{\"n\":87}\n{\"n\":88}\n{\"n\":89}\n{\"n\":9"…
---
data イベントの回数: 17
受け取ったと思った件数: 17

200回 write したのに、data は 17回しか起きていません。 1回目の data には、39件分がまとめて入っています。

もしここで JSON.parse(buf.toString()) と書いていたら、こうなります。

SyntaxError: Unexpected non-whitespace character after JSON at position 8

私が本番で見たのは、まさにこのエラーでした。 そして開発中は1回も出ませんでした。 手で1件ずつ投稿している間は、たまたま1対1で届いていたからです。

なぜまとまるのか

TCP は「バイトの流れ」しか運びません。 送った側の write の切れ目という情報は、そもそも運ばれません。

何が起きているか説明
送信側でまとまるOSが送信バッファに溜めて、まとめて1つのパケットで送る(ネーグルアルゴリズム)
受信側でまとまる届いたパケットが受信バッファに溜まり、アプリが読みに行ったときに全部渡される
逆に、割れることもある1回の write が大きいと、複数の data に分かれて届く(MTUを超えるため)

「まとまる」と「割れる」の両方が起きます。 つまり――

write の回数と data の回数には、何の関係もありません。 data の切れ目に意味を求めた瞬間、そのコードは壊れます。

直し方その1: 改行区切り

区切りは自分で決めるしかありません。 一番簡単なのは「改行までが1件」と決めることです。

やることは1つ。「余った分をためておく箱」を持つことです。

bash
$ cat > line-server.mjs <<'EOF'
  import net from 'node:net';
  
  const server = net.createServer((sock) => {
    let buffer = '';          // 途中で切れた分をためておく箱
    let events = 0, messages = 0;
  
    sock.on('data', (chunk) => {
      events++;
      buffer += chunk.toString();
  
      let i;
      while ((i = buffer.indexOf('\n')) !== -1) {   // 改行が見つかる限り取り出す
        const line = buffer.slice(0, i);
        buffer = buffer.slice(i + 1);               // 残りは次の data まで持ち越す
        if (line.length === 0) continue;
        messages++;
        const obj = JSON.parse(line);
        if (messages <= 2) console.log(`メッセージ ${messages}: n=${obj.n}`);
      }
    });
  
    sock.on('end', () => {
      console.log('---');
      console.log(`data イベントの回数: ${events}`);
      console.log(`組み立てたメッセージ数: ${messages}`);
      console.log(`箱に残ったバイト数: ${buffer.length}`);
      server.close();
    });
  });
  
  server.listen(9003, '127.0.0.1', () => console.log('listen 127.0.0.1:9003'));
  EOF

$ sed 's/9002/9003/' naive-client.mjs > line-client.mjs
$ node line-server.mjs &
$ sleep 1
$ node line-client.mjs
listen 127.0.0.1:9003
write を 200 回呼んだ
メッセージ 1: n=1
メッセージ 2: n=2
---
data イベントの回数: 5
組み立てたメッセージ数: 200
箱に残ったバイト数: 0

data は5回しか起きていないのに、200件ちょうど組み立てられました。 箱に残ったバイト数: 0 が「途中で切れたものが無い」証拠です。

ここが確認のポイントです。 最後に箱が空でなければ、半端なデータが残っている=プロトコルが合っていません。

改行区切りが壊れる場面

改行区切りには、はっきりした弱点があります。

中身に改行が入っていたら、そこで割れます。

実際に起こします。

bash
$ cat > line-break.mjs <<'EOF'
  import net from 'node:net';
  
  // 改行区切りで「生のテキスト」をやり取りするサーバー
  const server = net.createServer((sock) => {
    let buffer = '';
    let n = 0;
    sock.on('data', (c) => {
      buffer += c.toString();
      let i;
      while ((i = buffer.indexOf('\n')) !== -1) {
        const line = buffer.slice(0, i);
        buffer = buffer.slice(i + 1);
        console.log(`メッセージ ${++n}: ${JSON.stringify(line)}`);
      }
    });
    sock.on('end', () => { console.log(`合計 ${n} 件`); server.close(); });
  });
  
  server.listen(9005, '127.0.0.1', () => {
    const c = net.connect(9005, '127.0.0.1', () => {
      c.write('こんにちは\n');            // 1件のつもり
      c.write('1行目\n2行目\n');          // これも1件のつもり
      c.end();
    });
  });
  EOF
$ node line-break.mjs
メッセージ 1: "こんにちは"
メッセージ 2: "1行目"
メッセージ 3: "2行目"
合計 3 件

2件送ったのに3件になりました。 チャットで Shift+Enter の改行を許した瞬間、投稿が2つに割れます。

対処は2つあります。

  1. 中身をエスケープする(JSON.stringify すれば \n は \\n になるので割れない)
  2. そもそも改行に頼るのをやめる

2番目をやります。

直し方その2: 長さプレフィックス

「最初に本体の長さを書く」やり方です。中身に何が入っていても壊れません。

[4バイト: 本体の長さ][本体]
bash
$ cat > len-server.mjs <<'EOF'
  import net from 'node:net';
  
  const server = net.createServer((sock) => {
    let buffer = Buffer.alloc(0);
    let events = 0, messages = 0;
  
    sock.on('data', (chunk) => {
      events++;
      buffer = Buffer.concat([buffer, chunk]);
  
      for (;;) {
        if (buffer.length < 4) break;                 // 長さ4バイトすら届いていない
        const len = buffer.readUInt32BE(0);           // 先頭4バイト = 本体の長さ
        if (buffer.length < 4 + len) break;           // 本体がまだ全部来ていない
        const body = buffer.subarray(4, 4 + len);
        buffer = buffer.subarray(4 + len);            // 使った分だけ捨てる
        messages++;
        const obj = JSON.parse(body.toString());
        if (messages <= 2) console.log(`メッセージ ${messages}: ${JSON.stringify(obj.text)}`);
      }
    });
  
    sock.on('end', () => {
      console.log('---');
      console.log(`data イベントの回数: ${events}`);
      console.log(`組み立てたメッセージ数: ${messages}`);
      console.log(`箱に残ったバイト数: ${buffer.length}`);
      server.close();
    });
  });
  
  server.listen(9004, '127.0.0.1', () => console.log('listen 127.0.0.1:9004'));
  EOF

$ cat > len-client.mjs <<'EOF'
  import net from 'node:net';
  
  function frame(obj) {
    const body = Buffer.from(JSON.stringify(obj));
    const head = Buffer.alloc(4);
    head.writeUInt32BE(body.length, 0);
    return Buffer.concat([head, body]);
  }
  
  const sock = net.connect(9004, '127.0.0.1', () => {
    sock.write(frame({ text: '1行目\n2行目' }));       // 中に改行が入っている
    sock.write(frame({ text: 'あ'.repeat(30000) }));   // 1回では送りきれない大きさ
    for (let i = 0; i < 198; i++) sock.write(frame({ text: `n=${i}` }));
    console.log('write を 200 回呼んだ');
    sock.end();
  });
  EOF

$ node len-server.mjs > len.log 2>&1 &
$ sleep 1
$ node len-client.mjs
$ sleep 2
$ grep -E "^(listen|---|data |組み立て|箱に)" len.log
listen 127.0.0.1:9004
---
data イベントの回数: 4
組み立てたメッセージ数: 200
箱に残ったバイト数: 0

data が4回しか起きていないのに、200件ちょうど。 しかも、中に改行が入ったメッセージも、30000文字の巨大なメッセージも、全部正しく1件です。

grep を外して1件目だけ見ると、こうなっています。

メッセージ 1: "1行目\n2行目"

改行が中に入ったまま、1件として届いています。

2つのやり方の比較

改行区切り長さプレフィックス
実装簡単(indexOf('\n') だけ)やや面倒(Buffer を扱う)
中身に区切り文字壊れる(エスケープが要る)壊れない
人が読めるかnc で目視できる読めない(バイナリ)
事前に長さが要るか要らない本体を作りきってからでないと書けない
実物の例HTTP のヘッダ部, SMTP, Redis の一部WebSocket のフレーム, gRPC, MySQL の通信

WebSocket が長さプレフィックス方式なのは偶然ではありません。 中身が何であっても壊れないからです。⑦でそのフレームを実際に解読します。

📸 スクリーンショット2: naive-server.mjs の data イベントの回数: 17 と、 line-server.mjs の 組み立てたメッセージ数: 200 を並べて残す


④ UDP と比べる — 届く保証は無いが、区切りは保たれる

TCP の反対側を見ます。

UDP は「投げっぱなし」です。 届いたかも確認しないし、順番も直しません。 その代わり、TCP と正反対の性質を1つ持っています。

まず普通に投げる

bash
$ cat > udp-server.mjs <<'EOF'
  import dgram from 'node:dgram';
  
  const sock = dgram.createSocket('udp4');
  let count = 0;
  const seen = [];
  
  sock.on('message', (msg, rinfo) => {
    count++;
    const n = Number(msg.toString());
    if (count <= 3) console.log(`受信 ${count}: ${msg.length}バイト "${msg}" from ${rinfo.address}:${rinfo.port}`);
    seen.push(n);
  });
  
  sock.on('listening', () => console.log('UDP listen 127.0.0.1:9010'));
  sock.bind(9010, '127.0.0.1');
  
  setTimeout(() => {
    console.log('---');
    console.log(`受け取った件数: ${count} / 送られた件数: 5000`);
    const ordered = seen.every((v, i) => i === 0 || seen[i - 1] < v);
    console.log(`順番どおりだったか: ${ordered ? 'はい' : 'いいえ'}`);
    console.log(`最初の10件: ${seen.slice(0, 10).join(',')}`);
    sock.close();
  }, 4000);
  EOF

$ cat > udp-client.mjs <<'EOF'
  import dgram from 'node:dgram';
  
  const sock = dgram.createSocket('udp4');
  const N = 5000;
  
  for (let i = 1; i <= N; i++) {
    sock.send(String(i), 9010, '127.0.0.1');
  }
  console.log(`send を ${N} 回呼んだ`);
  setTimeout(() => sock.close(), 1500);
  EOF

$ node udp-server.mjs > udp.log 2>&1 &
$ sleep 1
$ node udp-client.mjs
$ sleep 5
$ cat udp.log
send を 5000 回呼んだ
UDP listen 127.0.0.1:9010
受信 1: 1バイト "1" from 127.0.0.1:58918
受信 2: 1バイト "2" from 127.0.0.1:58918
受信 3: 1バイト "3" from 127.0.0.1:58918
---
受け取った件数: 5000 / 送られた件数: 5000
順番どおりだったか: はい
最初の10件: 1,2,3,4,5,6,7,8,9,10

5000 回 send して、message イベントが 5000 回起きています。 ③の TCP では 200回の write が 17回でした。UDP は 1対1 です。

これが UDP の性質です。

UDP には区切りがあります。 1回の send が、そのまま1回の message になります。 フレーミングのコードを書かなくていい。 ③でやった苦労が、UDP では要りません。

落ちるところを見る

「届いた」のは、127.0.0.1(自分自身)だったからです。 ケーブルもルーターも通っていません。「落ちようがない」経路でした。

それでも落とせます。受信バッファを小さくします。

bash
$ cat > udp-server2.mjs <<'EOF'
  import dgram from 'node:dgram';
  
  // 受信バッファをわざと小さくする(既定は数百KB)
  const sock = dgram.createSocket({ type: 'udp4', recvBufferSize: 2048 });
  let count = 0;
  let last = 0, outOfOrder = 0;
  
  sock.on('message', (msg) => {
    count++;
    const n = Number(msg.toString().slice(0, 6));
    if (n < last) outOfOrder++;
    last = n;
  });
  
  sock.on('listening', () => {
    console.log(`UDP listen 127.0.0.1:9011 / recvBufferSize=${sock.getRecvBufferSize()}`);
  });
  sock.bind(9011, '127.0.0.1');
  
  setTimeout(() => {
    console.log('---');
    console.log(`送られた件数: 20000`);
    console.log(`受け取った件数: ${count}`);
    console.log(`失われた件数: ${20000 - count}(${((20000 - count) / 200).toFixed(1)}%)`);
    console.log(`順番が逆転した回数: ${outOfOrder}`);
    sock.close();
  }, 5000);
  EOF

$ cat > udp-client2.mjs <<'EOF'
  import dgram from 'node:dgram';
  const sock = dgram.createSocket('udp4');
  const N = 20000;
  const pad = 'x'.repeat(1000);
  for (let i = 1; i <= N; i++) sock.send(String(i).padStart(6, '0') + pad, 9011, '127.0.0.1');
  console.log(`send を ${N} 回呼んだ(1件 1006バイト)`);
  setTimeout(() => sock.close(), 2000);
  EOF

$ node udp-server2.mjs > udp2.log 2>&1 &
$ sleep 1
$ node udp-client2.mjs
$ sleep 6
$ cat udp2.log
send を 20000 回呼んだ(1件 1006バイト)
UDP listen 127.0.0.1:9011 / recvBufferSize=2048
---
送られた件数: 20000
受け取った件数: 18145
失われた件数: 1855(9.3%)
順番が逆転した回数: 0

自分から自分へ送っただけで、9.3% が消えました。 エラーは1つも出ていません。 送った側は「送れた」と思っています。

これが UDP の一番怖いところです。

UDP は「落ちた」ことを誰も教えてくれません。 アプリが自分で番号を振って、抜けを検出するしかありません。

同じことを TCP でやると、落ちません。 代わりに write が遅くなります(バッファが埋まると押し戻される)。 TCP は「落とさない代わりに待たせる」。UDP は「待たせない代わりに落とす」。 これが本質です。

対比表

TCPUDP
届く保証ある(届かなければ再送する)無い(消えても誰も気づかない)
順番の保証ある(並べ直してから渡す)無い(後から出したものが先に着く)
メッセージの区切り無い(ストリーム。自分で決める)ある(1 send = 1 message)
接続要る(3ウェイハンドシェイク)要らない(いきなり送る)
1件の上限無制限(流れ続ける)実用上 1400バイト程度まで
遅れたとき待って揃える(そのぶん遅延が伸びる)古いものは捨てて先へ進む
Node.js のモジュールnetdgram

それぞれ何に使われているか

用途どちらなぜそちらなのか
HTTP / HTTPSTCP1バイトでも欠けたらHTMLが壊れる
SSH / FTP / SMTPTCP同上。コマンドが化けたら事故
データベース接続TCP言うまでもない
DNSUDP(大きいときだけTCP)1往復で終わる。失敗したらもう1回聞けばいい
動画・音声通話UDP0.5秒前の映像が今届いても意味が無い。捨てて先へ行くのが正解
オンラインゲームUDP同上。古い座標より、新しい座標
QUIC(HTTP/3)UDPの上に自前で再送を実装TCPの「1つ詰まると全部止まる」を避けるため
NTP(時刻合わせ)UDP軽さが正義

「UDPは信頼できないから使わない」は間違いです。 遅れて届くくらいなら捨てたい用途では、UDPのほうが正しいのです。


⑤ ショートポーリングを実装して測る

ここからが冒頭の話です。 1秒ごとに聞きに行くコードを、実際に書いて測ります。

まずサーバーを作ります。10秒に1回だけ新しいメッセージが生まれる世界にします。 実際の掲示板もチャットも、たいていこうです。 大半の時間、何も起きていません。

bash
$ cat > chat-server.mjs <<'EOF'
  import http from 'node:http';
  
  const messages = [];               // 全メッセージ(メモリだけ)
  const waiters = [];                // ロングポーリングで待たせている人たち
  let reqCount = 0;                  // 受けたリクエストの総数
  let emptyCount = 0;                // 「新着ゼロ」で返した回数
  
  // 10秒に1回だけ、新しいメッセージが生まれる世界
  setInterval(() => {
    const m = { id: messages.length + 1, text: `メッセージ ${messages.length + 1}`, at: new Date().toISOString() };
    messages.push(m);
    console.log(`[生成] ${m.text}  待たせていた人: ${waiters.length}`);
    while (waiters.length) {
      const w = waiters.pop();
      clearTimeout(w.timer);
      w.send([m]);
    }
  }, 10000);
  
  const server = http.createServer((req, res) => {
    reqCount++;
    const url = new URL(req.url, 'http://127.0.0.1');
    const since = Number(url.searchParams.get('since') || 0);
    const fresh = messages.filter((m) => m.id > since);
  
    if (url.pathname === '/messages') {              // ショートポーリング
      if (fresh.length === 0) emptyCount++;
      res.writeHead(200, { 'content-type': 'application/json' });
      res.end(JSON.stringify(fresh));
      return;
    }
  
    if (url.pathname === '/wait') {                  // ロングポーリング
      const send = (list) => {
        res.writeHead(200, { 'content-type': 'application/json' });
        res.end(JSON.stringify(list));
      };
      if (fresh.length > 0) return send(fresh);      // すでに新着があるなら即返す
      const w = { send, timer: null };
      w.timer = setTimeout(() => {                   // 25秒で一度打ち切る(プロキシ対策)
        const i = waiters.indexOf(w);
        if (i >= 0) waiters.splice(i, 1);
        emptyCount++;
        send([]);
      }, 25000);
      waiters.push(w);
      req.on('close', () => {
        const i = waiters.indexOf(w);
        if (i >= 0) { clearTimeout(w.timer); waiters.splice(i, 1); }
      });
      return;
    }
  
    if (url.pathname === '/stats') {
      res.writeHead(200, { 'content-type': 'application/json' });
      res.end(JSON.stringify({ reqCount, emptyCount, messages: messages.length, waiting: waiters.length }));
      return;
    }
  
    res.writeHead(404); res.end('not found');
  });
  
  server.listen(9020, '127.0.0.1', () => console.log('listen 127.0.0.1:9020'));
  EOF

since を渡しているのが大事です。 「前に受け取った最後のID」を毎回送って、 その先だけ返してもらいます。これが無いと、毎回全件返ることになります。

クライアント側です。

bash
$ cat > short-poll.mjs <<'EOF'
  const DURATION = 60000, INTERVAL = 1000;
  let since = 0, requests = 0, empty = 0, got = 0;
  const t0 = Date.now();
  
  const timer = setInterval(async () => {
    requests++;
    const r = await fetch(`http://127.0.0.1:9020/messages?since=${since}`);
    const list = await r.json();
    if (list.length === 0) empty++;
    else { got += list.length; since = list[list.length - 1].id;
           console.log(`  +${((Date.now() - t0) / 1000).toFixed(1)}秒  新着 ${list.length} 件`); }
  }, INTERVAL);
  
  setTimeout(() => {
    clearInterval(timer);
    console.log('---');
    console.log(`経過:             ${DURATION / 1000} 秒`);
    console.log(`飛ばしたリクエスト: ${requests} 回`);
    console.log(`空振り:           ${empty} 回`);
    console.log(`受け取った新着:    ${got} 件`);
    console.log(`無駄だった割合:    ${(empty / requests * 100).toFixed(1)}%`);
  }, DURATION + 200);
  EOF

$ node chat-server.mjs > chat.log 2>&1 &
$ sleep 1
$ node short-poll.mjs

60秒待ちます。

  +9.1秒  新着 1 件
  +19.2秒  新着 1 件
  +29.3秒  新着 1 件
  +39.4秒  新着 1 件
  +49.4秒  新着 1 件
  +59.5秒  新着 1 件
---
経過:             60 秒
飛ばしたリクエスト: 59 回
空振り:           53 回
受け取った新着:    6 件
無駄だった割合:    89.8%

59回投げて、53回が空振りでした。無駄が 89.8%。

この数字を人数で伸ばす

1人でこれです。 掛け算するとこうなります。

同時に見ている人数1分あたりのリクエスト1時間あたりそのうち中身があるもの
1人59回3,540回6回(10.2%)
10人590回35,400回60回
100人5,900回354,000回600回
1,000人59,000回3,540,000回6,000回

1000人が画面を開いているだけで、1時間に354万リクエストです。 そして、そのうち約90%は「何もありません」を返すためだけに動いています。

さらに悪いこと: 遅延も減っていない

「1秒ごとに聞けば1秒以内に出る」と思うかもしれません。違います。

上の出力を見てください。メッセージが生まれるのは 9秒・19秒・29秒… のタイミングです。 受け取ったのは 9.1秒・19.2秒・29.3秒。平均で 0.5秒遅れています。

ポーリング間隔を N 秒にすると、平均遅延は N/2 秒になります。 遅延を半分にしたければ、リクエスト数は2倍。 交換条件から逃げられません。

間隔1人1時間のリクエスト平均遅延
10秒360回5.0秒
5秒720回2.5秒
1秒3,600回0.5秒
0.5秒7,200回0.25秒

この表を見ると、「そもそも間隔を短くする方向が間違っている」と分かります。 次にやることは、間隔を縮めることではありません。


⑥ ロングポーリング — サーバーが返事を保留する

発想を1つ変えます。

「無かったら空を返す」のをやめて、「あるまで返さない」ことにします。

コードでいうと、/wait の中のこの部分です(⑤のサーバーに実装済みです)。

if (fresh.length > 0) return send(fresh);      // すでに新着があるなら即返す
const w = { send, timer: null };
w.timer = setTimeout(() => { ... send([]); }, 25000);   // 25秒で一度打ち切る
waiters.push(w);                                // ⚠️ res を持ったまま返事をしない

res をその場で end() せず、配列に入れておくだけです。 新しいメッセージが生まれたときに、溜まっていた res を全部まとめて end() します。

クライアント側は「返ってきたら、すぐ次を投げる」だけの無限ループです。

bash
$ cat > long-poll.mjs <<'EOF'
  const DURATION = 60000;
  let since = 0, requests = 0, empty = 0, got = 0, running = true;
  const t0 = Date.now();
  
  async function loop() {
    while (running) {
      requests++;
      const r = await fetch(`http://127.0.0.1:9020/wait?since=${since}`);
      const list = await r.json();
      if (list.length === 0) empty++;                       // タイムアウトで空が返ってきた
      else { got += list.length; since = list[list.length - 1].id;
             console.log(`  +${((Date.now() - t0) / 1000).toFixed(1)}秒  新着 ${list.length} 件`); }
    }
  }
  loop();
  
  setTimeout(() => {
    running = false;
    console.log('---');
    console.log(`経過:             ${DURATION / 1000} 秒`);
    console.log(`飛ばしたリクエスト: ${requests} 回`);
    console.log(`空振り:           ${empty} 回`);
    console.log(`受け取った新着:    ${got} 件`);
    console.log(`無駄だった割合:    ${(empty / requests * 100).toFixed(1)}%`);
    process.exit(0);
  }, DURATION);
  EOF

3人同時に繋いだ状態で測ります。 途中で /stats を叩いて、サーバー側で何が起きているかも見ます。

bash
$ cat > lp-run.mjs <<'EOF'
  import { spawn } from 'node:child_process';
  const srv = spawn(process.execPath, ['chat-server.mjs'], { stdio: 'inherit' });
  await new Promise(r => setTimeout(r, 800));
  const cli = spawn(process.execPath, ['long-poll.mjs'], { stdio: 'inherit' });
  const c2 = spawn(process.execPath, ['long-poll.mjs'], { stdio: 'ignore' });
  const c3 = spawn(process.execPath, ['long-poll.mjs'], { stdio: 'ignore' });
  setTimeout(async () => {
    const s = await (await fetch('http://127.0.0.1:9020/stats')).json();
    console.log('35秒時点の /stats:', JSON.stringify(s));
  }, 35000);
  cli.on('exit', async () => {
    const s = await (await fetch('http://127.0.0.1:9020/stats')).json();
    console.log('最終 /stats:', JSON.stringify(s));
    srv.kill(); c2.kill(); c3.kill();
    process.exit(0);
  });
  EOF
$ node lp-run.mjs
listen 127.0.0.1:9020
[生成] メッセージ 1  待たせていた人: 3
  +9.2秒  新着 1 件
[生成] メッセージ 2  待たせていた人: 3
  +19.2秒  新着 1 件
[生成] メッセージ 3  待たせていた人: 3
  +29.2秒  新着 1 件
35秒時点の /stats: {"reqCount":13,"emptyCount":0,"messages":3,"waiting":3}
[生成] メッセージ 4  待たせていた人: 3
  +39.2秒  新着 1 件
[生成] メッセージ 5  待たせていた人: 3
  +49.2秒  新着 1 件
[生成] メッセージ 6  待たせていた人: 3
  +59.3秒  新着 1 件
---
経過:             60 秒
飛ばしたリクエスト: 7 回
空振り:           0 回
受け取った新着:    6 件
無駄だった割合:    0.0%
最終 /stats: {"reqCount":23,"emptyCount":0,"messages":6,"waiting":0}

何が変わったか

ショートポーリングロングポーリング
60秒のリクエスト数(1人)59回7回
空振り53回0回
無駄だった割合89.8%0.0%
受信のタイミング9.1 / 19.2 / 29.3秒9.2 / 19.2 / 29.2秒

リクエストが8分の1以下になりました。しかも遅延は変わっていません。

7回の内訳です。 6件のメッセージを受け取るのに6回、最後の1回は返事待ちのまま60秒が来て終了しました。

代償はサーバー側にある

35秒時点の /stats を見てください。

{"reqCount":13,"emptyCount":0,"messages":3,"waiting":3}

waiting: 3。3人ぶんの res を、サーバーが握ったままです。

外からも数えられます。 サーバーが動いている間に、別のターミナルで打ちます。

bash
$ ss -tn state established '( sport = :9020 )' | tail -n +2 | wc -l
3

3本の TCP 接続が、何もしていないのに開いたままです。

これがロングポーリングの正体です。

リクエストの「回数」は減りましたが、接続の「本数」は減っていません。 同時接続者の数だけ、サーバーが接続を持ち続けます。

そして、ここが罠です。

環境何が起きるか
Node.js / Go平気。1接続がイベントループの1エントリなので、数万本まで持てる
PHP-FPM / Apache prefork死ぬ。1接続 = 1プロセス。同時50人でワーカーが枯渇する
Rails / Django(同期)死ぬ。同上。専用のワーカーを分けるしかない
nginx を前に置いているproxy_read_timeout の既定は 60秒。それを超えると 504
クラウドのロードバランサアイドルタイムアウトが 60秒前後。同上

サーバー側のコードに setTimeout(..., 25000) を入れているのはこのためです。 プロキシに切られる前に、自分から一度返します。 25秒なら、たいていの既定値の内側に収まります。

nginx を挟むときの話は ポート番号を隠す — nginxのリバースプロキシ にあります。


⑦ SSE と WebSocket — 中身を生で見る

ロングポーリングまで来ると、次の疑問はこれです。

「毎回繋ぎ直さずに、開けっぱなしにして流し込めばいいのでは?」

それが SSE です。 そして SSE は、驚くほど「ただのHTTP」です。

SSE を書く

bash
$ cat > sse-server.mjs <<'EOF'
  import http from 'node:http';
  
  let n = 0;
  
  http.createServer((req, res) => {
    if (req.url !== '/events') { res.writeHead(404); return res.end(); }
  
    res.writeHead(200, {
      'content-type': 'text/event-stream',   // ⚠️ これだけが SSE の正体
      'cache-control': 'no-cache',
      'connection': 'keep-alive',
    });
    res.write('retry: 3000\n\n');            // 切れたら3秒後に再接続してね、という指示
  
    const timer = setInterval(() => {
      n++;
      res.write(`id: ${n}\n`);
      res.write(`event: message\n`);
      res.write(`data: ${JSON.stringify({ n, at: new Date().toISOString() })}\n\n`);
      if (n >= 3) { clearInterval(timer); res.end(); }
    }, 1000);
  
    req.on('close', () => clearInterval(timer));
  }).listen(9030, '127.0.0.1', () => console.log('listen 127.0.0.1:9030'));
  EOF

ライブラリを1つも使っていません。 res.write() を呼び続けているだけです。

curl で生のバイト列を見る

ここが「SSEはただのHTTP」の証明です。

bash
$ node sse-server.mjs > sse.log 2>&1 &
$ sleep 1
$ curl -sN -i http://127.0.0.1:9030/events

-N が重要です。 これが無いと curl がバッファリングして、最後にまとめて出ます。 リアルタイムに流れてくる様子が見えません。

HTTP/1.1 200 OK
content-type: text/event-stream
cache-control: no-cache
connection: keep-alive
Date: Fri, 04 Sep 2026 01:28:25 GMT
Transfer-Encoding: chunked

retry: 3000

id: 1
event: message
data: {"n":1,"at":"2026-09-04T01:28:26.213Z"}

id: 2
event: message
data: {"n":2,"at":"2026-09-04T01:28:27.228Z"}

id: 3
event: message
data: {"n":3,"at":"2026-09-04T01:28:28.237Z"}

1秒ごとに1ブロックずつ、目の前に出てきます。

これで全部です。バイナリは1バイトもありません。 curl で読める。grep できる。tee でファイルに残せる。 これが SSE の一番の長所です。

SSE の書式

行意味
data: ...本文。これだけが必須
id: ...イベントの番号。再接続のときに使われる
event: ...イベント名。ブラウザ側で addEventListener('その名前') で受けられる
retry: 3000切れたら何ミリ秒後に繋ぎ直すかの指示
空行ここまでが1イベント、という区切り

③でやった「フレーミング」が、ここにも出てきています。 SSE の区切りは「空行」です。 改行区切りの親戚で、data: の中に改行は書けません(複数行なら data: を並べます)。

Transfer-Encoding: chunked にも注目してください。 Content-Length を書けないからです。いつ終わるか分からないレスポンスなので、長さを先に言えません。

再接続がブラウザ側に入っている

SSE で一番おいしいのはここです。

ブラウザ側のコードはこれだけです。

const es = new EventSource('/events');
es.addEventListener('message', (e) => {
  console.log(JSON.parse(e.data));
});

再接続のコードが1行もありません。

サーバーが落ちても、Wi-Fi が切れても、ブラウザが retry: で指定した秒数後に自動で繋ぎ直します。 しかも Last-Event-ID というヘッダで「最後に受け取ったID」を送ってくれます。 サーバーはその続きから流せば、取りこぼしがゼロになります。

ロングポーリングで自分で書いていた while (running) のループが、ブラウザに最初から入っているということです。 これは自分で書くと必ずバグります(指数バックオフ、タブが非表示のとき、スリープ復帰後…)。

WebSocket — HTTP で挨拶してから乗り換える

SSE はサーバー → ブラウザの一方通行です。 逆方向は普通の fetch で送ります。 それで困る場面――ゲーム、共同編集、音声のやり取り――で初めて WebSocket が要ります。

WebSocket は「HTTPとは別のプロトコル」ですが、始まり方はHTTPです。

bash
$ cat > ws-server.mjs <<'EOF'
  import http from 'node:http';
  import crypto from 'node:crypto';
  
  const GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11';   // RFC 6455 が決めている固定文字列
  
  const server = http.createServer((req, res) => {
    res.writeHead(426, { 'content-type': 'text/plain' });
    res.end('Upgrade Required\n');   // 普通の GET には「乗り換えが要る」と返す
  });
  
  // ⚠️ HTTP のリクエストが「乗り換え」だったときだけ upgrade イベントが飛ぶ
  server.on('upgrade', (req, socket) => {
    const key = req.headers['sec-websocket-key'];
    console.log('--- クライアントから来たハンドシェイク ---');
    console.log(`${req.method} ${req.url} HTTP/${req.httpVersion}`);
    for (const [k, v] of Object.entries(req.headers)) console.log(`${k}: ${v}`);
  
    const accept = crypto.createHash('sha1').update(key + GUID).digest('base64');
    socket.write(
      'HTTP/1.1 101 Switching Protocols\r\n' +
      'Upgrade: websocket\r\n' +
      'Connection: Upgrade\r\n' +
      `Sec-WebSocket-Accept: ${accept}\r\n\r\n`
    );
    console.log(`--- 101 を返した(Accept: ${accept})---`);
  
    socket.on('data', (buf) => {
      console.log(`--- 生のフレーム ${buf.length} バイト ---`);
      console.log(buf.subarray(0, 16).toString('hex').replace(/(..)/g, '$1 ').trim());
      console.log(decodeFrame(buf));
    });
  });
  
  // 最小のフレーム解読(1フレームだけ。断片化・拡張は見ない)
  function decodeFrame(buf) {
    const b0 = buf[0], b1 = buf[1];
    const fin = (b0 & 0x80) >> 7;
    const opcode = b0 & 0x0f;
    const masked = (b1 & 0x80) >> 7;
    let len = b1 & 0x7f;
    let off = 2;
    if (len === 126) { len = buf.readUInt16BE(2); off = 4; }
    else if (len === 127) { len = Number(buf.readBigUInt64BE(2)); off = 10; }
    let mask = null;
    if (masked) { mask = buf.subarray(off, off + 4); off += 4; }
    const payload = Buffer.from(buf.subarray(off, off + len));
    if (mask) for (let i = 0; i < payload.length; i++) payload[i] ^= mask[i % 4];
    return { FIN: fin, opcode: `0x${opcode.toString(16)}`, masked, 長さ: len,
             マスク鍵: mask ? mask.toString('hex') : null, 中身: payload.toString() };
  }
  
  server.listen(9040, '127.0.0.1', () => console.log('listen 127.0.0.1:9040'));
  EOF

ws パッケージも入れていません。 http と crypto だけです。

まず普通の GET を投げてみる

bash
$ node ws-server.mjs > ws.log 2>&1 &
$ sleep 1
$ curl -si http://127.0.0.1:9040/ | head -8
HTTP/1.1 426 Upgrade Required
content-type: text/plain
Date: Fri, 04 Sep 2026 01:28:48 GMT
Connection: keep-alive
Keep-Alive: timeout=5
Transfer-Encoding: chunked

Upgrade Required

426 は「このリソースは、乗り換えないと使えません」という意味のステータスコードです。

curl でハンドシェイクを手で投げる

WebSocket のハンドシェイクは、ただのHTTPリクエストです。curlで書けます。

bash
$ curl -si -m 3 --http1.1 \
    -H "Connection: Upgrade" \
    -H "Upgrade: websocket" \
    -H "Sec-WebSocket-Version: 13" \
    -H "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==" \
    http://127.0.0.1:9040/

-m 3 を必ず付けてください。 付けないと 101 が返ったあと curl が永久に待ちます (プロトコルが乗り換わったので、curl はもう終わり方を知りません)。

HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=

これが「プロトコルが乗り換わった瞬間」です。 101 Switching Protocols。 ここから先、この TCP 接続の上を流れるバイトは、もう HTTP ではありません。

サーバー側のログです。

--- クライアントから来たハンドシェイク ---
GET / HTTP/1.1
host: 127.0.0.1:9040
user-agent: curl/8.12.1
accept: */*
connection: Upgrade
upgrade: websocket
sec-websocket-version: 13
sec-websocket-key: dGhlIHNhbXBsZSBub25jZQ==
--- 101 を返した(Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=)---

Sec-WebSocket-Accept は何をしているのか

暗号でも認証でもありません。

SHA1(クライアントが送った Key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11") を Base64

この固定文字列は RFC 6455 に書いてあり、誰でも知っています。

目的は「相手が本当に WebSocket を理解しているサーバーか」を確かめることだけです。 古いプロキシやキャッシュが、中身を理解しないまま 101 を返してしまう事故を防ぐためです。

上の s3pPLMBiTxaQ9kYGzzhZRbK+xOo= は、RFC 6455 の本文に載っている例と完全に一致します。 仕様どおりに実装できている証拠なので、自分で書いたときはここを見比べてください。

本物のクライアントで繋ぐ

Node.js 22 には WebSocket が組み込みで入っています。

bash
$ cat > ws-client.mjs <<'EOF'
  // Node.js 22 に組み込みの WebSocket クライアント(ライブラリ不要)
  const ws = new WebSocket('ws://127.0.0.1:9040/');
  ws.addEventListener('open', () => {
    console.log('open した');
    ws.send('hi');
    setTimeout(() => process.exit(0), 500);
  });
  ws.addEventListener('error', (e) => console.log('error', e.message));
  EOF
$ node ws-client.mjs
open した

サーバー側のログです。

--- クライアントから来たハンドシェイク ---
GET / HTTP/1.1
host: 127.0.0.1:9040
connection: upgrade
upgrade: websocket
sec-websocket-key: JSmrBuuEnzw07vf8HDHEsg==
sec-websocket-version: 13
sec-websocket-extensions: permessage-deflate; client_max_window_bits
accept: */*
accept-language: *
sec-fetch-mode: websocket
user-agent: node
pragma: no-cache
cache-control: no-cache
accept-encoding: gzip, deflate
--- 101 を返した(Accept: KTS4lyfLCWt00l2iqakPg1rjVQ0=)---
--- 生のフレーム 8 バイト ---
81 82 62 a5 cc 83 0a cc
{
  FIN: 1,
  opcode: '0x1',
  masked: 1,
  '長さ': 2,
  'マスク鍵': '62a5cc83',
  '中身': 'hi'
}

フレームを1バイトずつ読む

ws.send('hi') の2文字が、8バイトになっています。 中身を見ます。

バイト16進2進意味
0811000 0001FIN=1(これで最後)/ opcode=0x1(テキスト)
1821000 0010MASK=1(マスクあり)/ 長さ=2
2〜562 a5 cc 83マスク鍵(毎回ランダム)
6〜70a cc本体。鍵とXORして戻すと hi

0a cc は hi には見えません。 0x0a ^ 0x62 = 0x68 = 'h'、0xcc ^ 0xa5 = 0x69 = 'i' です。

主な opcode です。

opcode意味
0x0続き(前のフレームの続き)
0x1テキスト(UTF-8)
0x2バイナリ
0x8切断
0x9Ping
0xAPong

深追いはここまでにします。 断片化、permessage-deflate の圧縮、Ping/Pong のタイマー、閉じ方の作法――全部あります。

だから本番では ws パッケージを使ってください。 ここで自作する意味は「中身がバイナリのフレームであると知る」ことだけです。 それを知っていると、curl でデバッグできない理由も、プロキシで詰まる理由も分かります。

マスクは何のためか

クライアント → サーバーのフレームには、必ずマスクが要ります。 逆方向は不要です。

これはセキュリティのためです。 マスクが無いと、攻撃者が中身を完全に制御できるバイト列を、 古いプロキシに「HTTPリクエストのように見せかけて」流し込めてしまいます。 毎回ランダムな鍵でXORすることで、送るバイト列を狙って作れなくしています。

サーバーは止めておきます。

bash
$ pkill -f "node ws-server.mjs"; pkill -f "node sse-server.mjs"; echo done
done

📸 スクリーンショット3: curl -sN -i http://127.0.0.1:9030/events の出力と、 101 Switching Protocols が返っている curl -si の出力。この2つを並べて残す


⑧ 4つの判断表 — どれをいつ使うか

全部書いて、全部測りました。並べます。

性質の比較

ショートポーリングロングポーリングSSEWebSocket
方向双方向(毎回リクエスト)双方向(毎回リクエスト)サーバー→client のみ双方向
接続の数(1人あたり)0(都度張って切る)1本を握り続ける1本を握り続ける1本を握り続ける
60秒のリクエスト数(実測)59回7回1回1回
無駄だった割合(実測)89.8%0.0%0%0%
実装の手間(サーバー)ほぼゼロ中(res を溜める)小(res.write するだけ)大(ライブラリ必須)
実装の手間(client)小(setInterval)中(ループと再接続)極小(new EventSource)中(再接続を自分で書く)
プロキシとの相性完璧(ただのGET)タイムアウトに注意良い(ただのHTTP)要設定(Upgrade を通す設定が必要)
再接続要らない(毎回新規)自分で書くブラウザが自動(+ Last-Event-ID)自分で書く
HTTP/2 以上での多重化されるされるされる(同一接続に相乗り)されない(専用のTCP接続)
ブラウザの同時接続制限影響ありHTTP/1.1 だと6本まで同左(HTTP/2 なら解消)影響を受けにくい
バイナリ送れる送れる送れない(テキストのみ)送れる
curl でデバッグできるできるできる101 までしか見えない

選び方は3行

1. 更新が1分に1回で足りるなら、ショートポーリングで十分です。 59回 → 1回になれば無駄はほぼ消えます。 上の表の「89.8%」は1秒間隔だから出た数字です。 実装ゼロ、プロキシの心配ゼロ、再接続の心配ゼロ。捨てる理由がありません。

2. サーバーから通知したいだけなら、SSE です。 通知・進捗バー・株価・ログのライブ表示・AIの逐次出力。全部これで足ります。 再接続がブラウザに入っているのが決定的です。自分で書くと必ずバグります。

3. 双方向が本当に要るときだけ、WebSocket です。 共同編集、ゲーム、対戦、音声。 「ユーザーの操作を毎秒サーバーへ流す」必要がある場合。 それ以外は要りません。

やりがちな間違い

間違いなぜ違うか
チャットだから WebSocket送信は普通の POST で足ります。受信だけなら SSE で終わり
リアルタイムだから WebSocket「リアルタイム」の中身を秒で言えるか。5秒でよければポーリング
ポーリングは古い古くありません。一番壊れにくい方法です
SSE は使われていない主要なAIチャットの逐次表示はほぼSSEです。地味なだけで現役
WebSocket なら速い速いのは2回目以降です。最初のハンドシェイクは HTTP 1往復ぶん遅い
SSE も WebSocket も自動で再接続するSSEだけです。WebSocket は自分で書きます

全部に共通する、⑥で見た問題

SSE も WebSocket も、ロングポーリングと同じ「接続を持ち続ける」問題を抱えています。

気にすること対処
サーバーを1台増やしたら通知が届かない接続している台と、書き込みを受けた台が違う。Redis の Pub/Sub などで台を跨いで配る
デプロイのたびに全員切れる正常です。再接続が入っていれば問題にならない(=SSEが楽な理由)
プロキシに切られる30秒に1回、意味の無いデータ(SSEなら : ping\n\n)を流して黙らせる
同時接続の上限OSのファイルディスクリプタ上限。ulimit -n の既定 1024 はすぐ足りなくなる

1台で動かしているうちは、どれも同じに見えます。 差が出るのは2台目からです。


つまずいたところ

1. data イベントを1件のメッセージだと思っていた

これが全部の始まりです。 開発中は1回の write が1回の data になっていたので、気づけませんでした。 本番で件数が増えた瞬間、JSON.parse が Unexpected non-whitespace character で落ちました。 ③で 200回 → 17回 を目で見て、やっと納得しました。data の切れ目に意味はありません。

2. 改行区切りにしたのに、まだ壊れた

チャットの本文に改行が入っていました。 Shift+Enter を許した日に発生しました。 ③の line-break.mjs で再現したとおり、2件送って3件になります。 JSON.stringify すれば \n はエスケープされるので割れませんが、 「エスケープを忘れない」に頼る設計は、いつか忘れます。 長さプレフィックスに変えました。

3. ss を見たら 0.0.0.0:9001 になっていた

server.listen(9001) と書いて、IPアドレスを省略していました。 これはVMの全部のネットワークで待ち受けます。 ブリッジ接続にしていたら、LAN内から届きます。 練習用のサーバーには必ず '127.0.0.1' を書いてください。 私はこれを ② を書きながら直しました。

4. UDPで「1件も落ちなかった」ので、UDPは信頼できると思いかけた

127.0.0.1 には物理層がありません。 落ちようがない経路で測っていました。 recvBufferSize: 2048 に絞ったら、同じ localhost で 9.3% 消えました。 そして、送った側には何のエラーも出ていません。 これが一番怖いところです。

5. curl で SSE を見たら、何も出ずに固まった

-N を付けていませんでした。 curl は既定で出力をバッファリングします。 -N(--no-buffer)を付けると、届いた端から出ます。 同じ理由で、サーバー側に nginx を挟むと proxy_buffering off; が要ります。 私は最初「SSEが動かない」と思いましたが、動いていて、見えていなかっただけでした。

6. curl で WebSocket のハンドシェイクを投げたら、ターミナルが返ってこなくなった

101 を返した時点で、それはもう HTTP ではありません。 curl はいつ終わるか分からないので、待ち続けます。Ctrl+C で抜けられますが、 -m 3 を最初から付けてください。 私は3回 Ctrl+C を押してから気づきました。

7. WebSocket サーバーが ECONNRESET で落ちた

Error: read ECONNRESET
    at TCP.onStreamRead (node:internal/stream_base_commons:216:20)
Emitted 'error' event on Socket instance

socket.on('error', ...) を書いていませんでした。 upgrade イベントで受け取る socket は生のソケットで、エラーハンドラが無いとプロセスごと落ちます。 クライアントが process.exit() で乱暴に切っただけで、サーバー全体が死にました。

socket.on('error', (e) => console.log('[ソケットエラー]', e.code));

生のソケットを触るときは、必ず error を拾ってください。 例外ではなく、通常運転です。

8. ロングポーリングを PHP のサーバーで試して、サイト全体が止まった

同時に開いていたタブが10枚ほどで、他のページが全部開かなくなりました。 PHP-FPM は 1接続 = 1プロセスです。⑥の表のとおり、待たせている間ずっとワーカーを1つ占有します。 Node.js で同じことをしても平気なのは、待っている接続がイベントループの1エントリでしかないからです。 「ロングポーリング/SSE を入れるか」は、言語とサーバー構成の話です。 コードの話ではありません。


後片づけ

まず、走りっぱなしのサーバーが無いか確認します。

bash
$ ss -tlnp | grep -E ":90[0-9][0-9]"
(何も出なければOK)

残っていたら止めます。

bash
$ pkill -f "node .*\.mjs"; echo "終了コード: $?"
終了コード: 1

1 は「該当なし」です。 何も残っていなかったということなので、正常です。

もう一度確認します。

bash
$ ss -tan | grep -cE ":90[0-9][0-9]"
0

作業フォルダを消します。

bash
$ ls ~/cslab/rt
chat-server.mjs   len-client.mjs   line-client.mjs   sse-server.mjs   udp-client2.mjs
echo-client.mjs   len-server.mjs   line-server.mjs   udp-client.mjs   udp-server.mjs
echo-server.mjs   long-poll.mjs    lp-run.mjs        udp-server2.mjs  ws-client.mjs
naive-client.mjs  naive-server.mjs short-poll.mjs    ws-server.mjs    line-break.mjs

中身を見てから消してください。

bash
$ cd ~
$ rm -rf ~/cslab/rt
$ ls ~/cslab
(空、または他の記事のフォルダ)

rm -rf は戻せません。 パスを打つ前に ls で必ず確認します。

netcat を入れた人は、残しておいて構いません。 nc は「ポートが開いているか」を確かめる道具として、この先も使います。


まとめ — 理解できたこと

  • OSI の7層は暗記するものではない。 使うのは「いま困っているのはどの層か」の切り分けだけ
  • 実際に動いているのは TCP/IP の4層。 7層は地図、4層が実物
  • curl -w の DNS / TCP / TLS / firstbyte の4つの数字で、遅い層が1発で分かる。 アプリのコードを見るのは最後
  • HTTP も WebSocket も SSE も、sock.write() の上の「決めごと」でしかない。 管そのものは同じ
  • TCP はストリーム。200回 write して data は17回。 write の回数と data の回数に関係は無い
  • まとまるだけでなく、割れもする。 data の切れ目に意味を求めた瞬間にコードは壊れる
  • 区切りは自分で決める。 改行区切りは簡単だが、中身に改行が入ると2件に割れる(実測で2件が3件に)
  • 長さプレフィックスなら壊れない。 改行入りも30000文字も、data 4回で200件ちょうど組み立てられた
  • 最後に「箱」が空かどうかが、フレーミングが合っている証拠
  • UDP は TCP の逆。区切りは保つが、届く保証は無い(5000 send = 5000 message、ただし受信バッファを絞ると 9.3% 消えた)
  • UDP で落ちても、送った側にエラーは1つも出ない。 抜けの検出はアプリの仕事
  • DNS・動画・ゲーム・QUIC が UDP なのは、遅れて届くくらいなら捨てたいから
  • 1秒ポーリングは 60秒で59回、うち53回が空振り(89.8%が無駄)。 1000人なら1時間に354万回
  • ポーリング間隔 N 秒の平均遅延は N/2 秒。 遅延を半分にするとリクエストは2倍。間隔を縮める方向は間違い
  • ロングポーリングは同じ60秒で7回、空振り0回。遅延は変わらない
  • 代償は「接続を持ち続けること」(waiting: 3、ss でも3本)。PHP-FPM や同期フレームワークでは死ぬ
  • プロキシに切られる前に、25秒あたりで自分から一度返す
  • SSE は text/event-stream なだけのHTTPレスポンス。 curl -N で全部読める。区切りは空行
  • SSE の再接続はブラウザに入っている(retry: と Last-Event-ID)。これが自分で書くと必ずバグる部分
  • WebSocket は 101 Switching Protocols でプロトコルが乗り換わる。 そこから先はHTTPではない
  • Sec-WebSocket-Accept は暗号ではない。 古いプロキシの誤動作を防ぐための確認
  • フレームは長さプレフィックス方式(③でやったもの)。ws.send('hi') は8バイトになり、本体はXORでマスクされている
  • 結論は3行。通知だけなら SSE。双方向が要るときだけ WebSocket。1分に1回でよいならポーリングで十分

参考リンク


次に読む

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

記事
← 前の記事トランザクションとACID — ROLLBACKしたのに戻らない
→ 次の記事公開鍵暗号とTLS — 鍵は渡さずに秘密を共有する

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

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

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

›CS — Realtime Communication
  • TCP はストリームで区切りが無い
  • ポーリング / SSE / WebSocket を実測で選ぶ

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

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

コメント

コメントする

目次