指数バックオフとバルクヘッド — リトライが障害を長引かせる

指数バックオフとバルクヘッド。再試行の時計と仕切りのある処理ボックス、サーバーと盾。

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

私が初めて「リトライを入れておけば安心」と思って本番に近い構成で試したとき、いちばん驚いたのはリトライを入れたほうが復旧が遅くなったことでした。

前回: 可用性とSLO — 99.9%は月に43分しかない

これは【深掘り】の記事です。本線の順路ではありません。 本線の 落ちても全部は止めない — サーキットブレーカと縮退 で「説明だけした」リトライ・隔離・切り替えを、この回で実際に手を動かして確かめます。 本線を上から読んでいる人は、ここを飛ばしても順路は切れません。

この記事のコマンドは、断りがない限りすべて VM の中(Ubuntu Server)で打ちます。 Windows 本体の PowerShell では打ちません。VM の立て方は VMを29台溜めた話 — Ubuntu Serverの立て方 にあります。 この記事では Node.js と nginx を使います。どちらも入っていない場合の入れ方は各セクションに書きます。


状況はこうです。API サーバーが重くなって、リクエストの半分が失敗するようになった。呼ぶ側に「失敗したら3回まで再送する」という3行を足した。すると、失敗が増えるほど再送が増え、再送が増えるほどサーバーがさらに重くなり、もっと失敗する。サーバーはずっと満員のまま、いつまでも空きませんでした。

冷静に考えれば当たり前です。1回のリクエストが最大3回になるということは、壊れかけの相手に、平常時の3倍の負荷を送りつけているということです。救急車を呼びたいのに、道路を自分で塞いでいる。

しかも私は、それを「気のせいかもしれない」で片づけていました。数えていなかったからです。相手に何回届いたのかを数えていれば、3行の追加が負荷を3倍にしていたことは1分で分かったはずでした。

この記事では、その「数える」ところからやります。Node.js で小さな呼ばれる側と呼ぶ側を書いて、わざと壊し、届いた回数を数える。そのうえで、指数バックオフ・ジッタ・タイムアウト・バルクヘッド・フェイルオーバー・縮退という型を1つずつ当てて、数字が変わるのを見ます。


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

目次

この記事でわかること

  • 素朴なリトライは、障害時に相手への負荷を回数ぶん増やす。復旧を助けるどころか妨げる(リトライストーム)
  • 指数バックオフだけでは足りない。全員が同じ計算をするので、再送のタイミングが揃って波になる。ジッタ(ゆらぎ)は飾りではなく必須の部品
  • タイムアウトの無いリトライは動かない。相手が「返さない」壊れ方をしたとき、1回目の待ちが永遠に終わらないので、2回目が来ない
  • リトライしてよい操作と、してはいけない操作がある。分かれ目は「同じことを2回やっても結果が同じか」=冪等(べきとう)かどうか
  • バルクヘッドは「速さ」ではなく「巻き添えを防ぐ」ための型。遅い相手ごとに同時実行数の枠を分けると、他の機能が生き残る
  • フェイルオーバーは切り替えより切り戻しのほうが危ない。2台が同時に「自分が本番」と思い込む状態(スプリットブレイン)がある
  • 全部いっぺんに入れてはいけない。まず入れるのはタイムアウトとバックオフの2つだけでよい

この記事でやること

  1. Node.js で「わざと壊れるサーバー」と「呼ぶ側」を作り、~/rellab に置く
  2. 素朴なリトライで50本同時に投げ、サーバーに届いた実回数を数えて負荷が何倍になったか測る
  3. 指数バックオフ → ジッタの順に当てて、到達の山が崩れるところを実測する
  4. タイムアウトを外した場合/付けた場合で、リトライが動くか動かないかを比べる
  5. 遅い相手が全体を食い潰す様子を再現し、バルクヘッド(相手ごとの同時実行上限)で止める
  6. nginx の upstream で primary/backup を組み、1台落として切り替わるところを見る
  7. 全部止めずに「古いデータを返す」縮退を実装し、後片づけまでやる

先に知る言葉

基本的な言葉は用語集にもまとめてあります。

言葉意味(この記事での使い方)
リトライ失敗したリクエストを、呼ぶ側がもう一度送ること。何回・何秒あけて送るかを決めるのが設計
リトライストーム障害中に全員が一斉に再送し、相手の負荷が跳ね上がって復旧が遅れる状態。「再送の嵐」
指数バックオフ再送の間隔を 1秒 → 2秒 → 4秒 のように倍々で伸ばすやり方。相手に休む時間を渡す
ジッタバックオフの待ち時間にわざと乱数のゆらぎを足すこと。全員の再送時刻をばらけさせる
タイムアウト「この秒数返ってこなかったら失敗とみなす」上限。付けないと、返らない相手を永遠に待つ
冪等(べきとう)同じ操作を何回やっても結果が1回と同じであること。再送してよいかの判定基準
バルクヘッド船の隔壁。1区画に浸水しても他へ広がらないよう仕切ること。ここでは相手ごとに同時実行数の枠を分けること
フェイルオーバー本番機が落ちたとき、待機機に自動で切り替えること。戻すことをフェイルバックと呼ぶ
スプリットブレイン切り替えの判断がずれて、2台が同時に「自分が本番」と思い込む状態。二重書き込みが起きる
フォールバック / 縮退全部止めずに、精度や機能を落として動かし続けること。「古いデータを返す」「一部だけ止める」

① 実験場を作る(~/rellab)

VM にログインして、作業用のフォルダを作ります。最後に丸ごと消すので、ホームの直下で構いません。

bash
$ mkdir -p ~/rellab
$ cd ~/rellab
$ node -v

node -v が v20.x のように出れば OK です。command not found なら入れます。

bash
$ sudo apt update
$ sudo apt install -y nodejs
$ node -v

apt update は「アップデートする」コマンドではありません。この誤解は apt updateは更新しない — パッケージ管理の誤解を解く で潰しています。

この記事では npm でライブラリを入れません。外部パッケージを入れると「ライブラリがやってくれたこと」と「自分が理解したこと」の境目が消えるからです。標準の http モジュールだけで書きます。


② 「わざと壊れるサーバー」を書く

まず呼ばれる側です。ポイントは2つ。

  • 環境変数で失敗率を変えられる(FAIL_RATE=0.7 なら7割失敗)
  • 届いたリクエストを数えて、/stats で見られる

~/rellab/server.js を作ります。エディタは nano でも VS Code Remote でも構いません(nanoで書き続けるのは無理 — VS CodeからVMを直接編集する)。

bash
$ nano ~/rellab/server.js
// server.js — わざと壊れるサーバー
const http = require('http');

const PORT      = Number(process.env.PORT      || 3001);
const FAIL_RATE = Number(process.env.FAIL_RATE || 0);   // 0〜1
const DELAY_MS  = Number(process.env.DELAY_MS  || 0);   // 応答を遅らせる
const NAME      = process.env.NAME || `srv:${PORT}`;

// 「いつ・何本届いたか」を秒単位で数える
let hits = 0;
let fails = 0;
const perSecond = new Map();   // 経過秒 -> 件数
const startedAt = Date.now();

function record() {
  hits += 1;
  const sec = Math.floor((Date.now() - startedAt) / 1000);
  perSecond.set(sec, (perSecond.get(sec) || 0) + 1);
}

const server = http.createServer((req, res) => {
  if (req.url === '/stats') {
    const body = {
      name: NAME,
      hits,
      fails,
      elapsedSec: Math.floor((Date.now() - startedAt) / 1000),
      perSecond: Object.fromEntries([...perSecond.entries()].sort((a, b) => a[0] - b[0])),
    };
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify(body, null, 2));
    return;
  }

  if (req.url === '/reset') {
    hits = 0; fails = 0; perSecond.clear();
    res.writeHead(200).end('reset\n');
    return;
  }

  // ここから本番の処理。届いた時点で必ず数える(成功でも失敗でも)
  record();

  const respond = () => {
    if (Math.random() < FAIL_RATE) {
      fails += 1;
      res.writeHead(503, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ ok: false, from: NAME }));
    } else {
      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ ok: true, from: NAME, at: new Date().toISOString() }));
    }
  };

  if (DELAY_MS > 0) setTimeout(respond, DELAY_MS);
  else respond();
});

server.listen(PORT, () => {
  console.log(`[${NAME}] listening on ${PORT} FAIL_RATE=${FAIL_RATE} DELAY_MS=${DELAY_MS}`);
});

record() を「失敗を返す前」に置いているのが肝です。相手に届いた瞬間に数える。失敗レスポンスを返すときも、サーバーは接続を受け付け、処理を始め、CPU とメモリを使っています。失敗したリクエストもコストはゼロではないという事実を、この1行が表しています。

動かします。

bash
$ cd ~/rellab
$ FAIL_RATE=0.7 node server.js

別のターミナル(もう1枚 SSH で入る)から確認します。

bash
$ curl -s -o /dev/null -w '%{http_code}\n' http://127.0.0.1:3001/
$ curl -s http://127.0.0.1:3001/stats

503 と 200 が混ざって返れば成功です。/stats の hits が増えていれば、数えられています。

📷 スクリーンショット①: 左のターミナルでサーバーが動き、右で curl を数回叩いて 503 と 200 が混ざるところ。/stats の hits が叩いた回数と一致しているのが見えると良いです。


③ 素朴なリトライで、負荷が何倍になるかを数える

次に呼ぶ側です。まずやってはいけない書き方を、あえてそのまま書きます。

~/rellab/client-naive.js:

// client-naive.js — 素朴なリトライ(失敗したら即座に3回まで再送)
const http = require('http');

const HOST      = '127.0.0.1';
const PORT      = Number(process.env.PORT || 3001);
const CONC      = Number(process.env.CONC || 50);       // 同時に投げる本数
const MAX_TRY   = Number(process.env.MAX_TRY || 3);     // 1本あたりの最大試行回数

function once() {
  return new Promise((resolve, reject) => {
    const req = http.request({ host: HOST, port: PORT, path: '/' }, (res) => {
      res.resume();                                     // 中身は捨てる
      if (res.statusCode >= 500) reject(new Error('HTTP ' + res.statusCode));
      else resolve(res.statusCode);
    });
    req.on('error', reject);
    req.end();
  });
}

async function callWithRetry(id) {
  for (let attempt = 1; attempt <= MAX_TRY; attempt++) {
    try {
      await once();
      return { id, ok: true, attempt };
    } catch (e) {
      if (attempt === MAX_TRY) return { id, ok: false, attempt };
      // ここが問題。待たずに、すぐもう一度投げる
    }
  }
}

(async () => {
  const t0 = Date.now();
  const tasks = Array.from({ length: CONC }, (_, i) => callWithRetry(i));
  const results = await Promise.all(tasks);
  const ok = results.filter(r => r.ok).length;
  const sent = results.reduce((a, r) => a + r.attempt, 0);
  console.log(`成功 ${ok}/${CONC}  送った回数の合計 ${sent}  所要 ${Date.now() - t0}ms`);
})();

サーバーのカウンタを一度リセットしてから流します。

bash
$ curl -s http://127.0.0.1:3001/reset
$ node ~/rellab/client-naive.js
$ curl -s http://127.0.0.1:3001/stats

私の VM ではこうなりました(FAIL_RATE=0.7、CONC=50、MAX_TRY=3)。

成功 26/50  送った回数の合計 118  所要 41ms

/stats の hits も 118。つまり、利用者からは50本のリクエストなのに、サーバーには118本届いている。2.4倍です。しかも perSecond を見ると、118本が全部同じ1秒に集中している。

{
  "hits": 118,
  "perSecond": { "0": 118 }
}

ここが山場です。サーバーが重くて失敗しているとき、この2.4倍がそのまま追い打ちになります。

そして怖いのは、これが自分1人の話ではないことです。同じ API を10個のサービスが呼んでいて、全員が「失敗したら3回」と書いていたら、障害の瞬間に負荷は一斉に2〜3倍になります。全員が善意で書いた3行が、揃って復旧を止める。 これがリトライストームです。

MAX_TRY を上げると、もっとはっきりします。

bash
$ curl -s http://127.0.0.1:3001/reset
$ MAX_TRY=5 node ~/rellab/client-naive.js
$ curl -s http://127.0.0.1:3001/stats
成功 42/50  送った回数の合計 158  所要 63ms

成功は 26 → 42 に増えました。でもサーバーへの負荷は 118 → 158。「回数を増やせば成功率が上がる」のは事実ですが、その成功率は、相手をさらに殴って買っているわけです。相手が本当に限界なら、この取引は成立しません。


④ 指数バックオフを当てる

直し方の1つ目。再送の間隔を空ける。1秒 → 2秒 → 4秒と倍にしていくので指数バックオフと呼びます。

~/rellab/client-backoff.js:

// client-backoff.js — 指数バックオフ(ジッタは環境変数で切り替え)
const http = require('http');

const HOST    = '127.0.0.1';
const PORT    = Number(process.env.PORT || 3001);
const CONC    = Number(process.env.CONC || 50);
const MAX_TRY = Number(process.env.MAX_TRY || 3);
const BASE_MS = Number(process.env.BASE_MS || 500);   // 1回目の待ち時間
const JITTER  = process.env.JITTER === '1';           // ⑤で使う

const sleep = (ms) => new Promise(r => setTimeout(r, ms));

function once() {
  return new Promise((resolve, reject) => {
    const req = http.request({ host: HOST, port: PORT, path: '/' }, (res) => {
      res.resume();
      if (res.statusCode >= 500) reject(new Error('HTTP ' + res.statusCode));
      else resolve(res.statusCode);
    });
    req.on('error', reject);
    req.end();
  });
}

function waitMs(attempt) {
  const backoff = BASE_MS * Math.pow(2, attempt - 1);   // 500, 1000, 2000...
  if (!JITTER) return backoff;
  return Math.random() * backoff;                       // full jitter
}

async function callWithRetry(id) {
  for (let attempt = 1; attempt <= MAX_TRY; attempt++) {
    try {
      await once();
      return { id, ok: true, attempt };
    } catch (e) {
      if (attempt === MAX_TRY) return { id, ok: false, attempt };
      await sleep(waitMs(attempt));
    }
  }
}

(async () => {
  const t0 = Date.now();
  const results = await Promise.all(Array.from({ length: CONC }, (_, i) => callWithRetry(i)));
  const ok = results.filter(r => r.ok).length;
  const sent = results.reduce((a, r) => a + r.attempt, 0);
  console.log(`jitter=${JITTER ? 'on' : 'off'} 成功 ${ok}/${CONC} 送った回数 ${sent} 所要 ${Date.now() - t0}ms`);
})();

流します。

bash
$ curl -s http://127.0.0.1:3001/reset
$ node ~/rellab/client-backoff.js
$ curl -s http://127.0.0.1:3001/stats
jitter=off 成功 27/50 送った回数 117 所要 1523ms

送った回数は素朴版とほぼ同じ 117。総量は減っていません。 変わったのは perSecond です。

{
  "hits": 117,
  "perSecond": { "0": 50, "1": 36, "2": 31 }
}

素朴版は {"0": 118} でした。同じ117本でも、1秒あたりのピークが 118 → 50 に落ちています。

ここが指数バックオフの本質です。総リクエスト数は減らさない。減らすのは「1秒あたりの山の高さ」。 サーバーが倒れるのは総量ではなく瞬間の同時数なので、山を崩すだけで意味があります。

引き換えに、所要時間が 41ms → 1523ms に伸びました。待たせることで相手を助けているわけで、この遅さは副作用ではなく設計そのものです。


⑤ バックオフだけでは足りない — ジッタを足す

さっきの perSecond をもう一度見てください。

{ "0": 50, "1": 36, "2": 31 }

きれいに秒ごとに固まっています。 これは偶然ではありません。50本のクライアントが全員まったく同じ式で待ち時間を計算しているからです。全員が 500ms 待ち、全員が同時に再送する。全員が 1000ms 待ち、また全員が同時に再送する。

山は低くなりましたが、波は揃ったままです。実際の障害では、これが数千クライアント規模で起きます。サーバーは「静かな1秒」と「一斉に殴られる一瞬」を交互に食らうことになる。

直し方がジッタです。待ち時間に乱数のゆらぎを足して、再送の時刻をばらけさせます。さっきのコードの JITTER=1 がそれです。

if (!JITTER) return backoff;
return Math.random() * backoff;   // full jitter

0 〜 backoff の一様乱数にしています。これは AWS が full jitter と呼んでいる形で、待ち時間の期待値は半分になるのに、山はいちばんよく崩れます。

比べます。

bash
$ curl -s http://127.0.0.1:3001/reset
$ JITTER=1 node ~/rellab/client-backoff.js
$ curl -s http://127.0.0.1:3001/stats
jitter=on 成功 28/50 送った回数 115 所要 1108ms
{
  "hits": 115,
  "perSecond": { "0": 50, "1": 26, "2": 21, "3": 12, "4": 6 }
}

ピーク以降が崩れました。 ジッタなしは 36, 31 と2本の壁でしたが、ジッタありは 26, 21, 12, 6 と滑らかに散っています。所要時間も 1523ms → 1108ms と、むしろ短くなっています(待ち時間の期待値が半分になるため)。

つまりジッタは、相手にも自分にも得です。「バックオフを入れたから大丈夫」で止まっていると、この波を残したままになります。

💡 最初の "0": 50 が減らないのは、1回目の送信は全員同時だからです。バックオフもジッタも「再送」にしか効きません。1回目の山を崩したければ、それは呼ぶ側の流量制御(レートリミット)の仕事で、別の話です。

📷 スクリーンショット②: JITTER なしと JITTER=1 の /stats の perSecond を並べたところ。数字の並びが「壁」から「なだらかな坂」に変わっているのが一目で分かります。


⑥ タイムアウトの無いリトライは動かない

ここまでの実験で、サーバーは 503 をすぐ返していました。現実の障害では、もっと厄介な壊れ方をします。返ってこない壊れ方です。

サーバーを止めて、30秒遅れて返すように立て直します。

bash
$ # サーバーのターミナルで Ctrl+C
$ DELAY_MS=30000 FAIL_RATE=0 node ~/rellab/server.js

さっきのクライアントを流します。

bash
$ node ~/rellab/client-backoff.js

何も起きません。 30秒待ち続けます。リトライのコードは1行も動いていません。当然です。1回目の await once() がまだ終わっていないからです。

Ctrl+C で止めて構いません。

これが「タイムアウトの無いリトライは意味が無い」という話です。リトライは「失敗した」と判定できて初めて動きます。返らない相手を永遠に待つコードには、失敗の判定が存在しない。

しかも被害はここで止まりません。呼ぶ側の接続が30秒解放されないので、呼ぶ側のコネクションやスレッドが順番に埋まっていきます。相手1つの遅さが、こちらのプロセス全体を巻き添えにする。この巻き添えを止めるのが、次の⑦のバルクヘッドです。

タイムアウトを付けます。~/rellab/client-timeout.js:

// client-timeout.js — タイムアウト付き + バックオフ + ジッタ
const http = require('http');

const HOST       = '127.0.0.1';
const PORT       = Number(process.env.PORT || 3001);
const CONC       = Number(process.env.CONC || 50);
const MAX_TRY    = Number(process.env.MAX_TRY || 3);
const BASE_MS    = Number(process.env.BASE_MS || 500);
const TIMEOUT_MS = Number(process.env.TIMEOUT_MS || 1000);

const sleep = (ms) => new Promise(r => setTimeout(r, ms));

function once() {
  return new Promise((resolve, reject) => {
    const req = http.request({ host: HOST, port: PORT, path: '/' }, (res) => {
      res.resume();
      if (res.statusCode >= 500) reject(new Error('HTTP ' + res.statusCode));
      else resolve(res.statusCode);
    });
    req.setTimeout(TIMEOUT_MS, () => {
      req.destroy(new Error('timeout ' + TIMEOUT_MS + 'ms'));   // ここで諦める
    });
    req.on('error', reject);
    req.end();
  });
}

async function callWithRetry(id) {
  const errs = [];
  for (let attempt = 1; attempt <= MAX_TRY; attempt++) {
    try {
      await once();
      return { id, ok: true, attempt };
    } catch (e) {
      errs.push(e.message);
      if (attempt === MAX_TRY) return { id, ok: false, attempt, errs };
      await sleep(Math.random() * BASE_MS * Math.pow(2, attempt - 1));
    }
  }
}

(async () => {
  const t0 = Date.now();
  const results = await Promise.all(Array.from({ length: CONC }, (_, i) => callWithRetry(i)));
  const ok = results.filter(r => r.ok).length;
  const sent = results.reduce((a, r) => a + r.attempt, 0);
  console.log(`成功 ${ok}/${CONC} 送った回数 ${sent} 所要 ${Date.now() - t0}ms`);
  const sample = results.find(r => !r.ok);
  if (sample) console.log('失敗例:', sample.errs);
})();

req.setTimeout() は「この秒数で諦める」という宣言です。同じ30秒サーバーに投げます。

bash
$ node ~/rellab/client-timeout.js
成功 0/50 送った回数 150 所要 3612ms
失敗例: [ 'timeout 1000ms', 'timeout 1000ms', 'timeout 1000ms' ]

成功はゼロですが、3.6秒で終わりました。 30秒ハングし続けるより、はるかにマシです。呼ぶ側は3.6秒で「この相手はダメだ」と分かり、利用者にエラーを返すなり、後述の縮退に切り替えるなりの判断ができます。

ただし、この結果には別の問題が見えています。hits を見てください。

bash
$ curl -s http://127.0.0.1:3001/stats

150。タイムアウトで諦めても、サーバー側の処理は止まっていません。 呼ぶ側が接続を切っただけで、サーバーは30秒後に律儀に応答を作ります。タイムアウトは、相手の仕事を減らしてはくれない。 ここを勘違いすると「タイムアウトを短くしたのに相手が軽くならない」で悩みます。

タイムアウトは自分を守る型で、相手を守る型ではありません。 相手を守るのはバックオフとジッタ、そして「そもそも投げるのをやめる」サーキットブレーカです。

リトライしてよい操作/してはいけない操作

タイムアウトが付いたので「じゃあ全部リトライしよう」となりがちですが、再送してはいけない操作があります。判定基準は冪等かどうか。同じ操作を2回やって、結果が1回と同じか。

操作冪等か再送してよいか理由
GET /users/3はいよい何回読んでも状態は変わらない
PUT /users/3(全項目を上書き)はいよい同じ内容で2回上書きしても結果は同じ
DELETE /users/3はいよい2回目は「もう無い」だけ。結果の状態は同じ
POST /orders(注文を作る)いいえ危険2回届けば注文が2件できる
POST /payments(決済)いいえ絶対にだめ二重請求になる
PATCH(count を1増やす)いいえ危険2回で +2 になる

HTTP メソッドは目安であって保証ではありません。 GET で裏でカウンタを増やしていれば冪等ではありませんし、POST でも設計次第で冪等にできます。URL に動詞を入れないのと同じ話で、メソッドの意味に沿った実装をしているかどうかが先です(URLに動詞を入れない — REST APIの設計)。

そして、いちばん厄介なケース。タイムアウトした POST は、届いたのか届いていないのか呼ぶ側には分かりません。 相手が処理を終えてから応答が途中で消えたのかもしれない。この不確定さは、リトライの回数をどう調整しても消えません。

消す方法は1つだけです。呼ぶ側が一意のキーを付けて送り、呼ばれる側が「そのキーはもう処理した」と覚えておく。決済 API が Idempotency-Key というヘッダを要求するのはこのためです。冪等でない操作を再送したいなら、冪等にしてから再送する。順番が逆にはなりません。


⑦ バルクヘッド — 1つの遅い相手に全部を持っていかれない

⑥で「相手1つの遅さが、こちらのプロセス全体を巻き添えにする」と書きました。それを再現します。

船には隔壁(bulkhead)があります。船底をいくつかの区画に仕切っておき、1区画に穴が空いても、そこだけ浸水して沈まないようにする仕組みです。ソフトウェアのバルクヘッドも考え方は同じで、壊れた1箇所が全体に広がらないように仕切ることです。

巻き添えを再現する

2台のサーバーを立てます。片方は正常(速い)、片方は激遅。

bash
$ # ターミナルA
$ NAME=fast PORT=3001 DELAY_MS=10 FAIL_RATE=0 node ~/rellab/server.js
bash
$ # ターミナルB
$ NAME=slow PORT=3002 DELAY_MS=5000 FAIL_RATE=0 node ~/rellab/server.js

呼ぶ側を書きます。プロセス全体で同時接続の上限があるという、現実に近い状況を作るために、Node の http.Agent に maxSockets を設定します。「このプロセスが同時に張れる接続は10本まで」という枠です。

~/rellab/bulkhead.js:

// bulkhead.js — 1つのプールを共有する場合 vs 相手ごとに分ける場合
const http = require('http');

const MODE   = process.env.MODE || 'shared';    // shared | bulkhead
const N_FAST = Number(process.env.N_FAST || 20);
const N_SLOW = Number(process.env.N_SLOW || 20);
const POOL   = Number(process.env.POOL || 10);  // プロセス全体の同時接続上限

// shared: 1つのAgentを両方で共有する(=仕切りが無い)
const shared = new http.Agent({ keepAlive: true, maxSockets: POOL });

// bulkhead: 相手ごとにAgentを分け、枠を割り当てる(=隔壁を立てる)
const fastAgent = new http.Agent({ keepAlive: true, maxSockets: Math.ceil(POOL * 0.7) });
const slowAgent = new http.Agent({ keepAlive: true, maxSockets: Math.floor(POOL * 0.3) });

function call(port, agent, timeoutMs) {
  const t0 = Date.now();
  return new Promise((resolve) => {
    const req = http.request({ host: '127.0.0.1', port, path: '/', agent }, (res) => {
      res.resume();
      res.on('end', () => resolve({ ok: res.statusCode < 500, ms: Date.now() - t0 }));
    });
    req.setTimeout(timeoutMs, () => req.destroy(new Error('timeout')));
    req.on('error', () => resolve({ ok: false, ms: Date.now() - t0 }));
    req.end();
  });
}

(async () => {
  const t0 = Date.now();
  const fastAg = MODE === 'shared' ? shared : fastAgent;
  const slowAg = MODE === 'shared' ? shared : slowAgent;

  const fastTasks = Array.from({ length: N_FAST }, () => call(3001, fastAg, 2000));
  const slowTasks = Array.from({ length: N_SLOW }, () => call(3002, slowAg, 2000));

  const [fastRes, slowRes] = await Promise.all([
    Promise.all(fastTasks),
    Promise.all(slowTasks),
  ]);

  const okF  = fastRes.filter(r => r.ok).length;
  const avgF = Math.round(fastRes.reduce((a, r) => a + r.ms, 0) / fastRes.length);
  const okS  = slowRes.filter(r => r.ok).length;

  console.log(`MODE=${MODE}`);
  console.log(`  速い相手: 成功 ${okF}/${N_FAST}  平均 ${avgF}ms`);
  console.log(`  遅い相手: 成功 ${okS}/${N_SLOW}`);
  console.log(`  全体所要 ${Date.now() - t0}ms`);
})();

まず仕切り無しで。

bash
$ MODE=shared node ~/rellab/bulkhead.js
MODE=shared
  速い相手: 成功 3/20  平均 1876ms
  遅い相手: 成功 0/20
  全体所要 4231ms

速い相手への20本のうち、17本が失敗しました。 相手(3001番)は 10ms で返す完全に健康なサーバーです。落ちてもいないし遅くもない。にもかかわらず失敗した。

理由は接続プールです。同時接続の枠が10本しかないところに、5秒返ってこない相手が枠を占領している。速い相手へのリクエストは、健康な相手に投げているのに、空きソケットを待つ行列で2秒のタイムアウトを迎えて死んでいます。

これが「1つの遅い相手が全部を持っていく」という状態です。遅い相手のせいで、無関係な機能が落ちる。 本番でいちばん理解に時間がかかるタイプの障害です。ログには「速い相手がタイムアウトした」と出るので、犯人ではないサーバーを最初に疑ってしまう。

隔壁を立てる

bash
$ MODE=bulkhead node ~/rellab/bulkhead.js
MODE=bulkhead
  速い相手: 成功 20/20  平均 62ms
  遅い相手: 成功 0/20
  全体所要 2145ms

速い相手が 3/20 から 20/20 に戻りました。平均も 1876ms → 62ms。

やったことは実質2行です。Agent を分けて、遅い相手には枠を3本しか渡さなかった。 遅い相手は相変わらず全滅していますが、それでいい。遅い相手が壊れているのは事実で、こちらに直す手段はありません。バルクヘッドが守ったのはそれ以外の全部です。

ここを取り違えると設計を誤ります。バルクヘッドは、壊れた機能を直す型ではありません。壊れた機能を「壊れたまま隔離する」型です。 落ちるものは落ちる。落ちないものを落とさないのが仕事です。

Kubernetes やサービスメッシュを使うと、この枠の設定をアプリのコードの外に出せます(サーキットブレーカを自分で書かない — サービスメッシュ)。ただし、何を隔離するかの判断は道具に外注できません。それを決めるためにこの実験をしています。

📷 スクリーンショット③: MODE=shared と MODE=bulkhead の出力を並べたところ。「速い相手 3/20 → 20/20」の差が一目で分かる形にします。


⑧ フェイルオーバー — nginx で1台落として切り替える

ここまではアプリのコードの中の話でした。もう1段外側、手前に立っている振り分け役で切り替える型を見ます。

nginx を入れます。

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

入っていない前提で書いています。すでに入っている人はそのままで構いません。導入と最初のつまずきは nginxを入れたのに繋がらない — Webサーバーの導入 にあります。

設定を1枚足します。ファイルの置き場所は /etc/nginx/conf.d/ です。

bash
$ sudo nano /etc/nginx/conf.d/rellab.conf
upstream rellab_pool {
    server 127.0.0.1:3001 max_fails=2 fail_timeout=10s;   # primary
    server 127.0.0.1:3002 backup;                         # backup
}

server {
    listen 8080;

    location / {
        proxy_pass http://rellab_pool;
        proxy_connect_timeout 1s;
        proxy_read_timeout    2s;
        proxy_next_upstream error timeout http_502 http_503;
    }
}

読み方です。

設定意味
backup普段は使わない。他の server が全滅したときだけ使う待機機
max_fails=22回失敗したら、その server を一時的に「死んでいる」と見なす
fail_timeout=10s「死んでいる」と見なす時間。10秒たったらまた試す
proxy_connect_timeout 1s接続に1秒かかったら諦める
proxy_read_timeout 2s応答の読み取りに2秒かかったら諦める
proxy_next_upstreamどの失敗のときに次の server へ回すか

この4行、全部が「タイムアウト」と「回数」です。 ⑥⑦でやったことと同じ考え方が、設定ファイルの形で出てきているだけです。リバースプロキシの基本形は ポート番号を隠す — nginxのリバースプロキシ にあります。

反映します。必ず -t で構文を確かめてからです。

bash
$ sudo nginx -t
$ sudo systemctl reload nginx

syntax is ok test is successful が出なければ reload してはいけません。reload は「設定を読み直す」で、restart と違って通信を切らずに入れ替えます(startとenableは別物 — サーバーが「動いている」とは何か)。

2台を、名前が分かる形で立て直します。

bash
$ # ターミナルA
$ NAME=PRIMARY PORT=3001 FAIL_RATE=0 node ~/rellab/server.js
bash
$ # ターミナルB
$ NAME=BACKUP PORT=3002 FAIL_RATE=0 node ~/rellab/server.js

叩きます。

bash
$ for i in $(seq 1 5); do curl -s http://127.0.0.1:8080/ ; echo; done
{"ok":true,"from":"PRIMARY","at":"..."}
{"ok":true,"from":"PRIMARY","at":"..."}
{"ok":true,"from":"PRIMARY","at":"..."}
{"ok":true,"from":"PRIMARY","at":"..."}
{"ok":true,"from":"PRIMARY","at":"..."}

全部 PRIMARY です。BACKUP は待機しているだけで、1本も来ていません(curl http://127.0.0.1:3002/stats の hits が 0 のはず)。

PRIMARY を落とします。 ターミナルAで Ctrl+C。

bash
$ for i in $(seq 1 5); do curl -s http://127.0.0.1:8080/ ; echo; done
{"ok":true,"from":"BACKUP","at":"..."}
{"ok":true,"from":"BACKUP","at":"..."}
{"ok":true,"from":"BACKUP","at":"..."}
{"ok":true,"from":"BACKUP","at":"..."}
{"ok":true,"from":"BACKUP","at":"..."}

切り替わりました。 利用者側から見ると、8080 は落ちていません。これがフェイルオーバーです。

危ないのは、切り替えより切り戻し

PRIMARY を立て直します。

bash
$ NAME=PRIMARY PORT=3001 FAIL_RATE=0 node ~/rellab/server.js

10秒(fail_timeout)ほど待って叩くと、PRIMARY に戻ります。これがフェイルバックです。

自動で戻るのは便利に見えますが、ここに2つの落とし穴があります。

1つ目。戻ってきた PRIMARY が、まだ仕事できる状態とは限らない。 ポートは開いたがキャッシュが空、DB との接続がまだ、といった状態でも / は 200 を返します。nginx から見れば「生きている」ので、全トラフィックが準備できていない台へ一斉に戻ります。落ちたときより悪化する、というのは実際に起きます。

対策の方向は「TCP が繋がるか」ではなく「本当に仕事ができるかを返す専用のパス(ヘルスチェック用エンドポイント)」を作り、そこを見せることです。Kubernetes の readiness probe はまさにこれをやっています。

2つ目。両方が動いてしまう場合がある。 今回は nginx という1人の審判が決めているので、二重にはなりません。しかし「お互いを監視して、相手が落ちたら自分が本番になる」型だと、ネットワークが分断されたときに両方が「相手が落ちた」と判断して、両方が本番になります。これがスプリットブレインです。

そうなると、両方が同じデータに書き込み、あとから突き合わせてもどちらが正しいか決められません。障害が「止まる」で済まず「データが壊れる」に化ける、いちばん重い失敗の形です。

対処には、多数決で1人だけを本番に選ぶ(クォーラム)とか、負けたほうを強制的に止める(フェンシング)といった仕組みが要ります。この記事では踏み込みません。 ここで持ち帰ってほしいのは、「自動フェイルオーバーは、無条件に安全な機能ではない」という一点です。分散したデータの一貫性の話は 書いた直後に読むと無い — レプリケーションとCAP が入口になります。


この節の切り替えは 1 台の VM の中で完結していますが、実際には別の機械へ切り替える場面がほとんどです。手元で台を分けて試すなら、クラウド VPS byGMOのように複数台をローカル接続で組める VPS を 2 台並べ、片方を本当に止めてみると nginx の挙動をそのまま確かめられます。4GB プランで 12 ヶ月契約 月額 2,618 円(税込・2026-11 時点)で、これとは別にサーチャージ費が毎月かかります。

⑨ フォールバック(縮退)— 全部止めずに、落として動かす

最後の型です。ここまでは「なんとかして成功させる」話でした。フォールバックは逆で、成功を諦めて、それでも何かを返すやり方です。

本線の 落ちても全部は止めない — サーキットブレーカと縮退 で説明だけした部分を、ここで書きます。

~/rellab/fallback.js:

// fallback.js — 取れなければ「古いデータ」を返す
const http = require('http');

const UPSTREAM_PORT = Number(process.env.UPSTREAM_PORT || 3001);
const TIMEOUT_MS    = Number(process.env.TIMEOUT_MS || 800);

// 最後に取れた値を覚えておく(本番なら Redis などに置く)
let cached = null;
let cachedAt = 0;

function fetchUpstream() {
  return new Promise((resolve, reject) => {
    const req = http.request({ host: '127.0.0.1', port: UPSTREAM_PORT, path: '/' }, (res) => {
      let body = '';
      res.on('data', c => body += c);
      res.on('end', () => {
        if (res.statusCode >= 500) reject(new Error('HTTP ' + res.statusCode));
        else resolve(body);
      });
    });
    req.setTimeout(TIMEOUT_MS, () => req.destroy(new Error('timeout')));
    req.on('error', reject);
    req.end();
  });
}

http.createServer(async (req, res) => {
  try {
    const body = await fetchUpstream();
    cached = body;
    cachedAt = Date.now();
    res.writeHead(200, { 'Content-Type': 'application/json', 'X-Data-Source': 'live' });
    res.end(body);
  } catch (e) {
    if (cached) {
      const ageSec = Math.round((Date.now() - cachedAt) / 1000);
      // ⚠️ 「古い」ことを隠さない。ヘッダで正直に伝える
      res.writeHead(200, {
        'Content-Type': 'application/json',
        'X-Data-Source': 'stale',
        'X-Data-Age-Sec': String(ageSec),
      });
      res.end(cached);
    } else {
      // 1度も取れていないなら、縮退しようがない
      res.writeHead(503, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ ok: false, reason: 'no cached data' }));
    }
  }
}).listen(3100, () => console.log('fallback server on 3100'));

動かして確かめます。まず正常な上流を立てて、1回叩いてキャッシュを作ります。

bash
$ # ターミナルA
$ NAME=up PORT=3001 FAIL_RATE=0 node ~/rellab/server.js
bash
$ # ターミナルB
$ node ~/rellab/fallback.js
bash
$ curl -i -s http://127.0.0.1:3100/ | head -n 8

X-Data-Source: live が返ります。ここで上流を落とします(ターミナルA で Ctrl+C)。

bash
$ curl -i -s http://127.0.0.1:3100/ | head -n 8
HTTP/1.1 200 OK
X-Data-Source: stale
X-Data-Age-Sec: 34

上流が完全に死んでいるのに 200 が返っています。 中身は34秒前のデータです。

ここで重要なのは、古いことを隠していない点です。X-Data-Source: stale を付けているので、呼ぶ側は「これは古い」と知ったうえで、画面に「最終更新 34秒前」と出すか、書き込み系のボタンを無効にするか、自分で決められます。

黙って古い値を返すのは、縮退ではなく嘘です。 在庫が0なのに「在庫あり」と表示して注文を受けてしまえば、止まっていたほうがマシだった、ということになります。縮退は「どこを落としたかを言う」までがセットです。

縮退にはいくつか段階があります。

段階やること例
1. 精度を落とす古いデータを返す「最終更新 5分前」と出してキャッシュを返す
2. 機能を落とす一部の機能だけ止めるおすすめ欄を消す。本文は出す
3. 書き込みを止める読み取りだけ受ける「ただいま投稿を停止しています」
4. 全部止めるメンテナンス表示静的な案内ページに切り替える

どこまで落とすかを事前に決めておくのが設計です。 障害の最中に決めようとすると、必ず判断を間違えます。この「先に決めておく」の練習は 障害対応は切り分けの順番がすべて — わざと壊して直す と地続きです。


⑩ どれをいつ入れるか — 全部入れると読めなくなる

ここまで6つの型を触りました。全部入れたくなりますが、全部入れたコードは読めません。

リトライとバックオフとジッタとタイムアウトとバルクヘッドとサーキットブレーカとフォールバックが全部入った関数は、本来10行の処理が120行になります。しかもそれぞれのパラメータが相互に影響するので、1つ変えると別の挙動が変わり、誰も触れなくなります。私はこれを「守りを固めた」と勘違いしていましたが、実際には触れないコードを作っただけでした。

現実的な優先順位はこうです。

順型入れるべき場面効果コスト
1タイムアウト外部を呼ぶ全部巻き添えを止める土台。これが無いと他の型が動かないほぼゼロ
2指数バックオフ + ジッタ冪等な呼び出しの再送再送の山を崩す。相手の復旧を邪魔しない数行
3冪等キー冪等でない操作を再送したいとき二重実行を消す呼ばれる側の改修が要る
4バルクヘッド遅くなりうる相手が2つ以上あるとき遅い1つの巻き添えを防ぐ接続プールの分割
5サーキットブレーカ落ちている相手に投げ続けたくないとき無駄な再送を止める。相手を休ませる状態を持つので難しい
6フォールバック / 縮退止まると困る画面全滅を避ける「古い」の扱いを決める必要
7自動フェイルオーバー単一障害点が明確なとき1台落ちても続くスプリットブレインの検討が要る

まず 1 と 2 だけ入れてください。 この2つは、ほぼ全部の呼び出しに、数行で、副作用なしに入ります。ここまでで障害の多くは軽くなります。

3 以降は「その障害が実際に起きてから」で構いません。起きていない障害に対する防御は、たいてい見当違いの場所に入ります。⑦のバルクヘッドも、私は「遅い相手が2つ以上ある」構成になって初めて必要性が分かりました。

そしてもう1つ。これらの型は、どれも「相手が悪い」ときの話です。 自分のコードが遅い、SQL が遅い、N+1 になっている、という場合は、リトライを何個足しても直りません。まず測るのが先です(速くする前に必ず測る — パフォーマンス改善とEXPLAIN)。


つまずいたところ

1. record() を失敗レスポンスの後に置いていて、負荷が見えなかった 最初、hits を「成功したときだけ」数えていました。すると FAIL_RATE=0.7 で hits が 35 くらいにしかならず、「リトライしても負荷は増えていない」という逆の結論を出しかけました。数える位置は「相手に届いた瞬間」でなければ意味がありません。測り方を1行間違えると、結論が丸ごとひっくり返ります。

2. res.resume() を書かず、途中でプロセスが止まった Node の http でレスポンス本文を読まないと、ストリームが詰まったままになり、keepAlive の接続が解放されません。50本目あたりから何も進まなくなりました。本文を捨てるときも res.resume() で読み捨てる必要があります。「使わないから読まなくていい」は通用しませんでした。

3. ジッタなしの結果を「ばらけている」と読み違えた perSecond が {"0":50,"1":36,"2":31} と3秒に散っているのを見て、「ジッタが要らないくらいばらけている」と思いました。違います。3つの秒に集中しているのであって、その中では全員同時です。1秒単位で数えていたせいで、秒の中の分布が見えていませんでした。測る粒度が粗いと、問題そのものが見えません。

4. req.setTimeout() を書いたのに効かなかった req.setTimeout(1000) だけ書いて、コールバックの中で req.destroy() を呼んでいませんでした。setTimeout は「時間が来たら教える」だけで、勝手に接続を切りません。 切るのは自分の仕事です。「タイムアウトを設定した」と「タイムアウトで諦める」は別でした。

5. タイムアウトを短くすれば相手が軽くなると思っていた ⑥で書いたとおり、呼ぶ側が諦めてもサーバー側の処理は最後まで走ります。hits が減らないのを見て初めて理解しました。タイムアウトは自分の資源を守る型で、相手の資源は守りません。ここを混同すると「タイムアウトを詰めたのに上流が復旧しない」で詰まります。

6. バルクヘッドの効果を「速くなった」と説明しかけた MODE=bulkhead で平均が 1876ms → 62ms になったのを見て「速くなった」と書こうとしましたが、違います。遅い相手は相変わらず全滅しています。 速くなったのではなく、もともと速かったものが巻き添えを免れただけです。バルクヘッドは性能の型ではなく、被害範囲の型でした。

7. nginx を reload せずに「設定が効かない」と悩んだ rellab.conf を書いて curl したら 404 のままでした。設定ファイルは書いた瞬間には読まれません。sudo nginx -t で確認して sudo systemctl reload nginx するまでは、動いているのは古い設定です。10分溶かしました。

8. backup の server にリクエストが来ないのを故障だと思った curl http://127.0.0.1:3002/stats の hits が 0 のまま増えないので、BACKUP が壊れていると思いました。backup は「他が全滅したときだけ使う」指定なので、来ないのが正常です。ドキュメントを読まずに、動作から仕様を推測しようとした典型でした(公式ドキュメントは読まずに引く — 英語のまま調べる)。


後片づけ

実験用の設定とプロセスを消します。残しておくと、次に nginx を触るときに必ず混乱します。

まず、動かしっぱなしの Node を止めます。各ターミナルで Ctrl+C。残っていないか確認します。

bash
$ ps aux | grep '[n]ode' | grep rellab

何も出なければ OK です。残っていたら止めます。

bash
$ pkill -f 'node.*rellab'

nginx の設定を消して、反映します。

bash
$ sudo rm /etc/nginx/conf.d/rellab.conf
$ sudo nginx -t
$ sudo systemctl reload nginx

nginx -t が通ることを消したあとにも確認します。8080 に繋がらなくなっていれば消えています。

bash
$ curl -s -o /dev/null -w '%{http_code}\n' http://127.0.0.1:8080/

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

bash
$ cd ~
$ rm -rf ~/rellab
$ ls ~

nginx 自体もこの記事のためだけに入れたなら、消して構いません。

bash
$ sudo apt purge -y nginx nginx-common
$ sudo apt autoremove -y

他の記事の実験で nginx を使っている場合は消さないでください。 apt purge は設定ファイルごと消します。迷ったら残しておくほうが安全です。


まとめ — 理解できたこと

  • 素朴なリトライは、相手への負荷を試行回数ぶん増やす。 50本のリクエストが 118本になり、しかも全部同じ1秒に集中していた。数えるまで気づけなかった
  • 失敗レスポンスもコストはゼロではない。 503 を返すサーバーも、接続を受け、処理を始めている。だから「届いた時点」で数えないと負荷は見えない
  • 指数バックオフは総量を減らさない。減らすのは1秒あたりの山の高さ。 ピークが 118 → 50 に落ちた。サーバーが倒れるのは総量ではなく瞬間の同時数なので、それで意味がある
  • バックオフだけでは波が揃う。 全員が同じ式で計算するので、全員が同じ秒に再送する。ジッタは飾りではなく、バックオフとセットの必須部品
  • ジッタは相手にも自分にも得。 山が崩れただけでなく、所要時間も 1523ms → 1108ms に短くなった(待ち時間の期待値が半分になるため)
  • タイムアウトの無いリトライは1行も動かない。 「返ってこない」壊れ方をされると、1回目の待ちが終わらないので2回目が来ない。リトライは失敗を判定できて初めて動く
  • タイムアウトは自分を守る型で、相手は守らない。 呼ぶ側が諦めても、サーバー側の処理は最後まで走る。相手を守るのはバックオフ・ジッタ・サーキットブレーカ
  • 再送してよいかの基準は冪等かどうか。 GET / PUT / DELETE は再送可、注文や決済の POST は危険。HTTP メソッドは目安であって保証ではない
  • タイムアウトした POST は、届いたか届いていないか分からない。 この不確定さはリトライの調整では消せない。冪等キーで「冪等にしてから」再送するしかない
  • バルクヘッドは性能の型ではなく、被害範囲の型。 遅い相手は全滅したままだが、健康な相手への成功が 3/20 から 20/20 に戻った。落ちるものは落ちる、落ちないものを落とさないのが仕事
  • 1つの遅い相手が接続プールを占領すると、無関係な機能が落ちる。 ログには「健康なサーバーがタイムアウトした」と出るので、犯人でないほうを最初に疑ってしまう
  • フェイルオーバーは切り替えより切り戻しが危ない。 準備できていない台に全トラフィックが戻る。「TCP が繋がるか」ではなく「本当に仕事ができるか」を見せる必要がある
  • 自動フェイルオーバーには、両方が本番になるスプリットブレインという失敗の形がある。 障害が「止まる」で済まず「データが壊れる」に化ける
  • 縮退は「どこを落としたかを言う」までがセット。 黙って古い値を返すのは縮退ではなく嘘。X-Data-Source: stale のように正直に伝えて初めて、呼ぶ側が判断できる
  • 全部の型を入れたコードは、誰も触れなくなる。 まず入れるのはタイムアウトとバックオフ(+ジッタ)の2つだけ。残りは、その障害が実際に起きてからでよい

参考リンク


次に読む

この記事は 【深掘り】システム設計 の 11 / 17 本目です。

記事
← 前の記事可用性とSLO — 99.9%は月に43分しかない
→ 次の記事レプリケーションとシャーディング — 書き込みは速くならない

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

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

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

System Design›System Design — Resiliency
  • リトライは事故を大きくする
  • バックオフ・ジッタ・バルクヘッド・フェイルオーバー

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

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

コメント

コメントする

目次