落ちても全部は止めない — サーキットブレーカと縮退

サーキットブレーカと縮退。通信のスイッチとサーバー、迂回する経路と保護の盾。

障害対応の回で、わざと壊して、直しました。あれで手に入れたのは 「壊れたあと、どう辿るか」 です。

前回: 読んでも消えないキュー — Kafkaとオフセット 作業場所はVMの中(Ubuntu Server)です。~/server(Express + MySQL + Redis)、nginx の振り分け、Prometheusで監視を始める|メトリクスの収集方式とログとの違いと分散トレーシングの導入|どの処理が遅いかを特定するが動いている状態から始めます。

この記事は、その続きです。 扱うのは、壊れたあとではなく 壊れている最中 の話です。

一部が壊れたときに、全部を道連れにしないこと。

なぜこれを今やるかというと、マイクロサービスの回で、こう書いたからです。

分けた瞬間、関数呼び出しが「失敗しうる通信」になる。

そして、私たちはもう 分けています。 マイクロサービスにしていなくても、~/server はすでに MySQL・Redis・nginx という別プロセスに、ネットワーク越しで頼っています。頼っている先は、落ちます。

そこで、いきなり手を動かします。 Redis を止めてください。それだけです。

bash
$ sudo systemctl stop redis-server

そしてブラウザでアプリを開くと、ページが真っ白になります。

Redisの回で、私たちは cacheGet() を try で包んで、「Redis が落ちてもキャッシュミスと同じ扱いにする」ところまでやったはずです。それなのに真っ白です。

この記事は、その理由を突き止めるところから始まります。

対象レベル: 中級 / 区分: 必修

目次

この記事でわかること

  • 「キャッシュは落ちても大丈夫に書いた」つもりでも、セッションの置き場所が同じ Redis なら全部止まること
  • タイムアウトを書いていない外部呼び出しが1本あるだけで、無関係なAPIまで死ぬこと。それがカスケード障害だということ
  • 落ちている相手には、失敗を「早く返す」ほうがマシだということ。待つのは親切ではなく攻撃だということ
  • 素直なリトライは、弱った相手にとどめを刺すこと(リトライストーム)。ジッターが要る理由
  • サーキットブレーカは3つの状態を持つ変数にすぎず、ライブラリ無しで30行で書けること
  • 縮退とは「全部か無か」をやめること。遅くても返す・一部を消して返すという選択肢があること
  • これは複数のサービスがあるときの道具であること。1台のうちはタイムアウトだけで十分だということ

この記事でやること

  1. Redis を止めて、ページが真っ白になるのを再現し、原因を切り分ける
  2. わざと返事をしない相手を1つ立て、DBの接続が10本とも埋まって全滅するところまで再現する(この記事の山場)
  3. タイムアウトを入れて、同じ攻撃で落ちなくなることを確かめる
  4. リトライを、指数バックオフとジッター付きで入れる
  5. サーキットブレーカを自分で書く(閉 / 開 / 半開)。開いたことをログに出す
  6. 縮退とバルクヘッドを入れ、止めたものを全部戻して後片づけする

先に知る言葉

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

言葉意味
カスケード障害1か所の故障が、次々と隣に燃え移って全体が止まること。ドミノ倒し
タイムアウト「ここまで待って返事が無ければ諦める」時間。待ち続けないための上限
コネクションプールDBへの接続を数本だけ作って使い回す仕組み。本数には上限がある(既定10本)
リトライ失敗したときにもう一度やり直すこと
リトライストームみんなが一斉にやり直して、弱った相手に前より多い量が届くこと。事故が大きくなる
指数バックオフやり直す間隔を、1秒・2秒・4秒と倍にしていくこと
ジッター待ち時間にわざと乱数のばらつきを混ぜること。全員の再挑戦がそろわないようにする
サーキットブレーカ相手が壊れていると判断したら、しばらく呼ぶのをやめて即座に失敗を返す仕組み。家の分電盤のブレーカと同じ
縮退運転(グレースフルデグラデーション)一部の機能を諦めて、残りを動かし続けること。全滅させない
バルクヘッド船の隔壁。同時実行数を区切って、1つの故障が資源を全部食い潰さないようにする
冪等(べきとう)何回やっても結果が同じこと。GET は冪等、POST の決済は冪等ではない
フェイルファストダメなときは、待たずにすぐ失敗を返すという考え方

① なぜ Redis を止めただけで真っ白になったのか

さっき止めたままのはずです。 まず現象を、思い込みではなく数字で見ます。

bash
$ systemctl is-active redis-server
$ curl -i http://127.0.0.1:3000/api/stats

500 が返ります。 そして ~/server のログを見ます。

bash
$ sudo journalctl -u myserver@3000 -n 30 --no-pager

切り分ける

障害対応の回の型どおり、上から順に潰します。

見るもの結果
nginx は生きているか生きている(502 ではなく 500 が返っている=後ろまでは届いている)
アプリは生きているかsystemctl is-active myserver@3000 は active
MySQL は生きているか生きている
Redis止めた。ここが原因

ここまでは想定どおりです。問題は「なぜ 500 になるのか」です。

キャッシュは、落ちても平気なように書いてあります。

const cacheGet = async (key) => {
  try {
    return await redis.get(key);
  } catch {
    return null;        // 繋がらなければ「ミス」と同じ扱いにする
  }
};

この書き方は正しいままです。 犯人は別のところにいました。

bash
$ grep -n "session\|RedisStore\|connect-redis" ~/server/app.js

セッションの保存先です。

負荷分散の回で、アプリを2つに増やしたらログインが切れました。それを直すために、セッションを Redis に移しました。 つまり ~/server の中には、Redis に頼っている場所が2つあります。

頼っている場所落ちたら書き方
キャッシュ(cacheGet)キャッシュミス扱い。DBから返る⭕ 包んである
セッションストアrequireLogin が通らない → 全ルートが 500❌ 包んでいない

「落ちても大丈夫に書いた」のは、2つのうち1つだけでした。 そして落ちなかったほう(キャッシュ)は目立つほうで、落ちたほう(セッション)は自分で書いた覚えがほとんど無いほうでした。

これが、この記事全体を貫く話です。

障害に強いかどうかは、「一番弱い依存が、一番目立たないところにある」かどうかで決まります。

[スクリーンショット: 01_redis_down_500.png] sudo systemctl stop redis-server のあとに curl -i http://127.0.0.1:3000/api/stats を実行して、500 が返っている画面を撮ってください。

いったん戻す

先に進む前に、必ず戻してください。

bash
$ sudo systemctl start redis-server
$ redis-cli -a "$(grep -oP '(?<=REDIS_PASSWORD=).*' ~/server/.env)" ping

PONG が返れば復旧です。

redis-cli -a にパスワードを直接打たないでください。 ターミナルの履歴に残ります。上の書き方は .env から取り出して渡しているので、画面にも履歴にも残りません。

② 返事をしない相手が1つあるだけで、全部が死ぬ

ここがこの記事で一番大事な節です。

さっきの Redis は「すぐエラーになる」故障でした。それは、実はマシなほうの故障です。

本当に怖いのは、落ちる故障ではありません。 「生きているけれど、返事をしない」故障です。

わざと返事をしない相手を立てる

「おすすめ記事を返してくれる別サービス」という設定にします。VMの中で作ります。

bash
$ mkdir -p ~/slowsvc
$ nano ~/slowsvc/slow.js
const http = require("http");

// 接続は受け付けるが、返事をしない。落ちてはいない
http.createServer((req, res) => {
  console.log(new Date().toISOString(), "接続を受けました:", req.url);
  // res.end() を呼ばない。相手はずっと待つ
}).listen(3999, "127.0.0.1", () => console.log("slow.js が 3999 で待っています"));

別のターミナル(VMの中)で起動しておきます。

bash
$ node ~/slowsvc/slow.js

これは「壊れたサーバー」の一番いやらしい再現です。 ポートは開いているので接続は成功します。 だから TCP の層では何の異常も出ません。

アプリから、タイムアウト無しで呼ぶ

~/server/app.js に、次のルートを足します。 これは やってはいけない書き方の見本 です。

// ⚠️ 悪い例。このあと直します
app.get("/api/recommend", requireLogin, async (req, res) => {
  try {
    const rows = await knex.transaction(async (trx) => {
      const [me] = await trx("users").where({ id: req.session.userId });
      const r = await fetch(`http://127.0.0.1:3999/recommend?user=${me.id}`);
      const items = await r.json();
      return items;
    });
    res.json(rows);
  } catch (err) {
    console.error("[recommend]", err.message);
    res.status(500).json({ error: "おすすめを取得できませんでした" });
  }
});

この20行に、事故の種が3つ入っています。 いまは気づかなくて構いません。このあと自分の目で見ます。

再起動します。

bash
$ sudo systemctl restart myserver@3000
$ sudo systemctl is-active myserver@3000

まず1本だけ叩く

ログイン済みのクッキーが要ります。 認証の回で作ったログインを使って、クッキーをファイルに取ります。

bash
$ cd ~
$ curl -s -c cookie.txt -X POST http://127.0.0.1:3000/api/login \
    -H "Content-Type: application/json" \
    -d '{"email":"me@example.com","password":"ここは自分のパスワード"}'

そのクッキーで、1本だけ呼びます。

bash
$ curl -s -b cookie.txt -o /dev/null -w "%{http_code} %{time_total}s\n" \
    --max-time 20 http://127.0.0.1:3000/api/recommend

20秒たっても返りません。 curl 側の --max-time で打ち切られます。

curl を諦めさせても、アプリの中の処理は生きたまま待ち続けています。 ここが肝心です。 クライアントが帰っても、サーバーは待つのをやめません。

ここからが本題 — 関係ないAPIを巻き添えにする

別のターミナルで、同じ /api/recommend を同時に12本投げます。

bash
$ for i in $(seq 1 12); do
$   curl -s -b ~/cookie.txt --max-time 60 http://127.0.0.1:3000/api/recommend > /dev/null &
$ done

投げたら、5秒ほど待ってから、まったく関係ないAPIを叩いてください。

bash
$ curl -s -b ~/cookie.txt -o /dev/null -w "%{http_code} %{time_total}s\n" \
    --max-time 90 http://127.0.0.1:3000/api/stats

1分ほど待たされたあと、/api/stats が 500 を返します(knex は既定で、接続の空きを60秒待ってから諦めます)。おすすめ機能とは、コードの上で1文字も関係がないのにです。ログを見ます。

bash
$ sudo journalctl -u myserver@3000 -n 20 --no-pager
[recommend] Knex: Timeout acquiring a connection. The pool is probably full.
Error: Knex: Timeout acquiring a connection. The pool is probably full.
Are you missing a .transacting(trx) call?

これがカスケード障害です。

何が起きたのか

絵で言うと、こうです。

段起きたこと
1slow.js が返事をしない
2/api/recommend が、DBの接続を1本つかんだまま待ち続ける(knex.transaction の中で fetch している)
3同じことが12本。knex のプールは既定で最大10本
410本が全部埋まる
5/api/stats が接続を借りようとして、借りられずに死ぬ
6アプリ全体が 500 を返す。ページは真っ白

落ちたのは「おすすめ」だけのはずでした。実際に落ちたのは、サービス全部です。

さっき「事故の種が3つある」と書いたのは、これです。

種なぜまずいか
fetch にタイムアウトが無い待つ上限が無い。相手が返事をしなければ永遠に待つ
外部呼び出しを transaction の中でやっている待っている間ずっとDBの接続を握っている。一番希少な資源を、一番遅い処理が占有する
同時実行数に上限が無い1つの機能が、プールを全部食い潰せてしまう

この3つを、これから順に潰します。 1つ目がタイムアウト、2つ目が縮退の考え方、3つ目がバルクヘッドです。

[スクリーンショット: 02_pool_exhausted.png] journalctl に Knex: Timeout acquiring a connection. The pool is probably full. が出ている画面を撮ってください。

片づけます。 走っている curl を止めて、アプリを再起動します。

bash
$ kill $(jobs -p) 2>/dev/null
$ sudo systemctl restart myserver@3000

③ タイムアウトを入れる(一番効く1行)

この記事でやることの中で、費用対効果が飛び抜けて高いのがこれです。

タイムアウトは「遅い相手を切る設定」ではありません。 「自分の資源が、いつ返ってくるかを保証する設定」です。

Node.js には、そのための書き方が用意されています。

const r = await fetch(url, { signal: AbortSignal.timeout(800) });

AbortSignal.timeout(800) は 800ミリ秒たったら、その fetch を中断してくれる合図です。中断されると TimeoutError が投げられます。

さっきのルートを、こう直します。

app.get("/api/recommend", requireLogin, async (req, res) => {
  try {
    // ① DBの用事は先に終わらせて、接続を返す
    const [me] = await knex("users").where({ id: req.session.userId });

    // ② 外部呼び出しは、DBの接続を持っていない状態でやる
    const r = await fetch(`http://127.0.0.1:3999/recommend?user=${me.id}`, {
      signal: AbortSignal.timeout(800),
    });
    if (!r.ok) throw new Error(`recommend が ${r.status} を返しました`);

    res.json(await r.json());
  } catch (err) {
    console.warn("[recommend]", err.name, err.message);
    res.status(503).json({ error: "おすすめは一時的に利用できません" });
  }
});

変えたのは3つです。

  1. transaction をやめた。 DBの用事を先に済ませ、接続を返してから外を呼びます
  2. AbortSignal.timeout(800) を付けた
  3. 500 ではなく 503 を返すようにした。 503 は「一時的に無理」という意味で、自分のバグではなく相手の不調だと後で読み分けられます

再起動して、さっきと同じ攻撃をかけます。

bash
$ sudo systemctl restart myserver@3000
$ for i in $(seq 1 12); do
$   curl -s -b ~/cookie.txt --max-time 60 http://127.0.0.1:3000/api/recommend > /dev/null &
$ done
$ curl -s -b ~/cookie.txt -o /dev/null -w "%{http_code} %{time_total}s\n" http://127.0.0.1:3000/api/stats

今度は /api/stats が 200 を、いつもの速さで返します。 /api/recommend は 0.8 秒で 503 を返して終わります。

おすすめ機能は壊れたままです。それでいいのです。 壊れたものが1つで済んだ、というのが今回の成果です。

どれくらいの値にするか

「とりあえず3秒」と書きたくなります。 それだと根拠が無いので、詰まったときに動かせません。決め方は3つあります。

(1)実測の p95 から決める

トレーシングの回で、どこに何ミリ秒かかっているかを見られるようになりました。あるいは監視の回のヒストグラムでも構いません。

タイムアウト ≒ ふだんの p95 の 3〜4倍

p95 が 200ms なら 600〜800ms です。平均ではなく p95 を使うのは、平均は遅い側の裾を隠すからです。

(2)上から予算を配る(タイムアウト予算)

呼ぶ側のタイムアウトは、呼ばれる側より必ず長くなければいけません。 逆だと、下が頑張って返した頃には上が諦めています。

層値理由
ブラウザ(利用者の我慢)約3秒ここが全体の上限
nginx → アプリ2秒ブラウザより短く
アプリ → おすすめサービス800msさらに短く
アプリ → Redis300msキャッシュは速いのが取り柄。遅いなら使わないほうが速い

上から下へ、必ず短くしていきます。 これをタイムアウト予算と呼びます。

(3)人間の感覚を下限にする

利用者が待てるのは3秒程度です。どれだけ丁寧に計算しても、その中に収まらないなら、そもそも設計が間違っています。

忘れがちな2か所にも入れる

fetch だけ直して満足しないでください。 待つ場所は他にもあります。

Redis クライアント(app.js の接続部分):

const redis = createClient({
  url: process.env.REDIS_URL,
  socket: {
    connectTimeout: 300,
    reconnectStrategy: (retries) => Math.min(retries * 200, 3000),
  },
});

knex のプール(プールが空のとき、いつまで待つか):

const knex = require("knex")({
  client: "mysql2",
  connection: { /* いままでどおり */ },
  pool: { min: 2, max: 10, acquireTimeoutMillis: 3000 },
});

nginx(後ろのアプリが返事をしないときの上限):

bash
$ sudo nano /etc/nginx/sites-available/myapp
proxy_connect_timeout 2s;
proxy_send_timeout    5s;
proxy_read_timeout    5s;
bash
$ sudo nginx -t && sudo systemctl reload nginx

nginx -t が OK を出すまで reload しないでください。 リバースプロキシの回と同じ手順です。

④ リトライ — 素直に書くと事故が大きくなる

タイムアウトを入れると、次にこう思います。

「失敗したなら、もう一度やればいいのでは?」

半分正しく、半分は危険です。

まず、危険なほうから

素直なリトライは、こうなります。

// ⚠️ これは書いてはいけません
for (let i = 0; i < 3; i++) {
  try { return await fetch(url); } catch {}
}

何が起きるか、数字で見ます。 相手が重くて、毎秒100件の要求をさばけずに落ちかけているとします。

相手に届く量
リトライ無し100 /秒
3回リトライ300 /秒

弱っている相手に、いつもの3倍を送りつけています。

これがリトライストームです。相手が回復しかけた瞬間に、全員のリトライが同時に着弾して、また落ちます。 そして落ちたのでまたリトライする。永久に立ち上がれません。

しかも、全員が同じタイミングで失敗しているので、リトライも同じタイミングでそろいます。

指数バックオフとジッター

直し方は2つ同時に入れます。

対策やること
指数バックオフ待つ時間を倍にしていく(200ms → 400ms → 800ms)。回復する時間を相手に与える
ジッター待ち時間に乱数を混ぜる。全員の再挑戦がそろわないようにする
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

async function retry(fn, { attempts = 3, baseMs = 200 } = {}) {
  let lastErr;
  for (let i = 0; i < attempts; i++) {
    try {
      return await fn();
    } catch (err) {
      lastErr = err;
      if (i === attempts - 1) break;
      const backoff = baseMs * 2 ** i;          // 200 → 400 → 800
      const wait = Math.random() * backoff;     // ⚠️ ここがジッター
      console.warn(`[retry] ${i + 1}回目失敗。${Math.round(wait)}ms 待ちます: ${err.message}`);
      await sleep(wait);
    }
  }
  throw lastErr;
}

Math.random() * backoff の1行がジッターです。「0からbackoffまでの間でばらけさせる」やり方で、AWS の文書では full jitter と呼ばれています。待ち時間の平均は半分になるのに、衝突は激減します。

ジッターを入れないバックオフは、ほとんど意味がありません。 全員が「1秒後」に同じことをするなら、それは1秒後に同じ事故が起きるだけだからです。

リトライしてはいけないもの

ここを間違えると、リトライは「不具合」ではなく「事故」になります。

相手の返事リトライ理由
接続できない / タイムアウト⭕ する相手に届いていない可能性がある
503 / 429⭕ する(Retry-After があれば従う)相手が「いまは無理」と言っている
500△ 原則しない相手のバグ。何度やっても同じ
400 / 401 / 404❌ 絶対にしないこちらが悪い。 100回やっても直らない

そして、返事の種類より大事な基準が1つあります。

冪等でない操作は、リトライしてはいけません。

「タイムアウトした」は「届かなかった」ではありません。 届いて、処理されて、返事だけが返ってこなかったかもしれません。

操作リトライすると
GET /api/tasks何回やっても同じ。安全
POST /api/payments(決済)2回引き落とされる可能性がある
POST /api/tasks(作成)同じタスクが2つできる

どうしてもリトライしたいなら、相手が「同じ依頼だ」と気づけるようにします。

await fetch(url, {
  method: "POST",
  headers: { "Idempotency-Key": requestId },  // 依頼ごとに1つ、変わらないID
  body: JSON.stringify(body),
});

受け側は、このIDをすでに処理済みなら、処理せずに前回の結果を返します。 トランザクションの回で作った一意制約が、ここで効きます。

「返事が要らない仕事」なら、そもそもリトライを自分で書かないほうが楽です。 メッセージキューの回でやったとおり、キューを挟めば、再送はキューの仕事になります。

使ってみる

さっきの /api/recommend に組み込みます。

const items = await retry(() =>
  fetch(url, { signal: AbortSignal.timeout(800) }).then((r) => {
    if (!r.ok) throw new Error(`recommend が ${r.status}`);
    return r.json();
  })
, { attempts: 2 });

attempts は 2 にしました。 3にしたくなりますが、タイムアウト 800ms × 3回 + 待ち時間で、利用者は2秒以上待たされます。リトライは、タイムアウト予算の中に収まる回数しかできません。

⑤ サーキットブレーカを、30行で書く

リトライまで入れて、まだ足りません。

slow.js はまだ返事をしません。 つまり、呼ぶたびに必ず 800ms を捨てています。 1分間に100回呼べば、80秒ぶんを、返ってこないと分かっている相手に払っているわけです。

相手が壊れているなら、呼ばないのが一番速い。

これがサーキットブレーカです。家の分電盤のブレーカと、考え方はまったく同じです。落ちているあいだ、電気は来ませんが、家は燃えません。

3つの状態しかない

状態何をするかいつ移るか
閉(closed)ふつうに呼ぶ。 失敗を数える失敗が閾値を超えたら → 開
開(open)呼ばない。即座に失敗を返す(フェイルファスト)一定時間たったら → 半開
半開(half-open)試しに1本だけ通す成功なら → 閉 / 失敗なら → 開

「閉じている=通電している=正常」です。日本語の直感と逆なので、ここだけ気をつけてください。

書く

ライブラリは使いません。 ~/server/breaker.js を作ります。

bash
$ nano ~/server/breaker.js
function createBreaker({ name = "breaker", failureThreshold = 5, openMs = 10000 } = {}) {
  let state = "closed";
  let failures = 0;
  let openedAt = 0;
  let trialInFlight = false;      // 半開のとき、通すのは1本だけ

  return async function call(fn) {
    if (state === "open") {
      if (Date.now() - openedAt < openMs) {
        throw new Error(`[${name}] 回路が開いています`);   // ← 呼ばずに即失敗
      }
      state = "half-open";
      trialInFlight = false;
      console.warn(`[breaker] ${name} → 半開(試しに1本だけ通します)`);
    }
    if (state === "half-open" && trialInFlight) {
      throw new Error(`[${name}] 半開の試行中です`);
    }
    if (state === "half-open") trialInFlight = true;

    try {
      const result = await fn();
      if (state !== "closed") console.warn(`[breaker] ${name} → 閉(復旧しました)`);
      state = "closed";
      failures = 0;
      trialInFlight = false;
      return result;
    } catch (err) {
      trialInFlight = false;
      failures++;
      if (state === "half-open" || failures >= failureThreshold) {
        state = "open";
        openedAt = Date.now();
        console.error(`[breaker] ${name} → 開(連続失敗 ${failures} 回。${openMs}ms 呼びません)`);
      }
      throw err;
    }
  };
}

module.exports = { createBreaker };

30行ちょっとです。 中身は 状態を持つ変数3つと、if が4つしかありません。

サーキットブレーカに難しい理論はありません。 「連続で失敗したら、しばらく呼ぶのをやめる」を、そのままコードにしただけです。 名前が仰々しいので身構えますが、自分で書けます。

なぜ「失敗を早く返す」ほうがマシなのか

ここを納得しないと、この道具は使えません。 3つ理由があります。

理由中身
自分を守る待っている間、こちらの資源(接続・メモリ・スレッド)は塞がっている。 ②で見たとおり
相手を守る落ちかけている相手への流量が、ゼロになる。 回復する時間を与えられる
利用者に早く伝えられる30秒待たせて「エラー」より、0.1秒で「いまおすすめは出せません」のほうがずっとマシ

待つのは親切ではありません。 相手が回復しようとしている最中に、要求を投げ続けるのは、攻撃と同じです。

組み込む

app.js の上のほうに1つ作ります。

const { createBreaker } = require("./breaker");
const recommendBreaker = createBreaker({ name: "recommend", failureThreshold: 5, openMs: 10000 });

ルートは、retry の外側を包みます。

app.get("/api/recommend", requireLogin, async (req, res) => {
  try {
    const [me] = await knex("users").where({ id: req.session.userId });
    const items = await recommendBreaker(() =>
      retry(() =>
        fetch(`http://127.0.0.1:3999/recommend?user=${me.id}`, {
          signal: AbortSignal.timeout(800),
        }).then((r) => {
          if (!r.ok) throw new Error(`recommend が ${r.status}`);
          return r.json();
        })
      , { attempts: 2 })
    );
    res.json(items);
  } catch (err) {
    console.warn("[recommend]", err.message);
    res.status(503).json({ error: "おすすめは一時的に利用できません" });
  }
});

入れ子の順番に意味があります。

ブレーカが外、リトライが内。 逆にすると、「開いている」という即失敗を、リトライが3回やり直すことになります。無意味な上に、ログが3倍出ます。

開くところを見る

bash
$ sudo systemctl restart myserver@3000
$ for i in $(seq 1 8); do
$   curl -s -b ~/cookie.txt -o /dev/null -w "%{http_code} %{time_total}s\n" \
      http://127.0.0.1:3000/api/recommend
$ done
503 1.712s
503 1.655s
503 1.783s
503 1.629s
503 1.748s
503 0.004s
503 0.003s
503 0.004s

6本目から、時間が 1.7 秒前後 → 0.004 秒に落ちています。 ここでブレーカが開きました。ログを見ます。

bash
$ sudo journalctl -u myserver@3000 -n 15 --no-pager | grep breaker
[breaker] recommend → 開(連続失敗 5 回。10000ms 呼びません)

10秒待ってからもう1本叩くと、半開になります。

bash
$ sleep 11 && curl -s -b ~/cookie.txt -o /dev/null -w "%{http_code}\n" http://127.0.0.1:3000/api/recommend
[breaker] recommend → 半開(試しに1本だけ通します)
[breaker] recommend → 開(連続失敗 6 回。10000ms 呼びません)

相手はまだ壊れているので、すぐ開に戻ります。正しい動きです。

[スクリーンショット: 03_breaker_open_log.png] journalctl に [breaker] recommend → 開 と → 半開 が並んでいる画面を撮ってください。

直したら閉じることを確かめる

slow.js を、ちゃんと返事をする版に差し替えます。

bash
$ nano ~/slowsvc/slow.js
const http = require("http");
http.createServer((req, res) => {
  res.setHeader("Content-Type", "application/json");
  res.end(JSON.stringify([{ id: 1, title: "おすすめ記事A" }]));
}).listen(3999, "127.0.0.1", () => console.log("slow.js(正常版)が 3999 で待っています"));

Ctrl+C で止めて、起動し直します。10秒待ってから叩きます。

bash
$ sleep 11 && curl -s -b ~/cookie.txt -o /dev/null -w "%{http_code}\n" http://127.0.0.1:3000/api/recommend
[breaker] recommend → 半開(試しに1本だけ通します)
[breaker] recommend → 閉(復旧しました)

200 が返り、ブレーカが自動的に閉じました。 誰も再起動していません。

これが半開の価値です。 開きっぱなしなら、人間が直すまで機能は死んだままです。 半開があるから、相手が直った瞬間に、勝手に戻ります。

⑥ 縮退 — 全部か無かにしない

ここまでは「呼ばない」話でした。 呼ばないと決めたあと、利用者に何を返すかが縮退です。

縮退とは、「全部動くか、全部死ぬか」という二択をやめることです。

(1)Redis が落ちたら、遅くてもDBから返す

①で見たとおり、cacheGet はすでに縮退しています。

const cached = await cacheGet(key);   // Redis が落ちていれば null
if (cached) return res.json(JSON.parse(cached));
// ↓ ミス扱いで、そのままDBを引く

Redis が落ちても、/api/stats は動きます。遅くなるだけです。

「速いが壊れやすい道」と「遅いが確実な道」を両方持って、前者がダメなら後者に落ちる。 これが縮退の一番きれいな形です。

ただし、これには前提が要ります。 DBが、キャッシュ無しの負荷に耐えられることです。パフォーマンスの回でやったとおり、キャッシュが無いと10秒かかるような処理なら、Redis が落ちた瞬間にDBが道連れになります。そのときは「遅くても返す」ではなく「その機能だけ諦める」に切り替えます。

(2)セッションは、縮退できない

①で真っ白の原因だったセッションはどうするか。

結論から書くと、ここは正直に諦めます。

「Redis が落ちたらログイン不要にする」は、絶対にやってはいけません。 認証を落とす縮退は、縮退ではなく穴です。

やるのは、これだけです。

やること意味
ログインが要らない画面は、Redis が落ちても表示できるようにするトップページや記事一覧を requireLogin の外に出す
500 ではなく「ログインが一時的にできません」を返す真っ白より、原因が分かるほうがまし

app.js のセッション設定の下に、これを足します。

// セッションストア(Redis)が落ちたときに、真っ白にしない
app.use((err, req, res, next) => {
  if (err && /session|redis/i.test(err.message)) {
    console.error("[session]", err.message);
    return res.status(503).json({ error: "ログイン機能が一時的に利用できません" });
  }
  next(err);
});

(3)おすすめ欄だけ消して、ページは出す

一番よく使う縮退はこれです。 画面側が 「1つでも失敗したら全部表示しない」書き方になっていると、全滅します。

bash
$ mkdir -p ~/server/public
$ nano ~/server/public/panel.html
// ⚠️ 悪い例。1つコケたら catch に飛んで、全部出ない
const [stats, tasks, recommend] = await Promise.all([
  fetch("/api/stats").then((r) => r.json()),
  fetch("/api/tasks").then((r) => r.json()),
  fetch("/api/recommend").then((r) => r.json()),
]);

Promise.all は「1つでも失敗したら、全部失敗」です。 非同期処理の回でやった性質が、そのまま障害に直結します。

Promise.allSettled に変えるだけで、縮退になります。

const results = await Promise.allSettled([
  fetch("/api/stats").then((r) => r.json()),
  fetch("/api/tasks").then((r) => r.json()),
  fetch("/api/recommend").then((r) => r.json()),
]);

const [stats, tasks, recommend] = results.map((r) =>
  r.status === "fulfilled" ? r.value : null
);

render({ stats, tasks });
if (recommend) {
  renderRecommend(recommend);     // 出せるときだけ出す
} else {
  hideRecommendPanel();           // ⚠️ エラーを出すのではなく、欄ごと消す
}

「おすすめを取得できませんでした」と赤字を出すより、欄ごと消すほうがいい場面が多いです。 利用者は、そもそもその欄があったことを知りません。

代替値には落とし穴がある

「失敗したら、代わりに何か返せばいい」は、行き過ぎると危険です。

やっていい縮退やってはいけない縮退
おすすめ欄を消す在庫数を、取れなかったので「あり」と返す
キャッシュが無いのでDBから引く残高が取れなかったので 0 円と返す
少し古いデータを返す(stale-while-revalidate)権限が取れなかったので「許可」にする

「安全側に倒す」の安全側が、どっちなのかを毎回考えてください。 迷ったら、嘘の値を返すより、正直に 503 を返すほうがましです。

そしてもう1つ。代替の道も、ふだんから動かしてください。 障害のときにしか通らないコードは、障害のときに動きません。 これは AWS の技術文書でも繰り返し警告されている話です。

⑦ バルクヘッド — 同時実行数を区切る

②で見つけた「事故の種」の3つ目が、まだ残っています。 1つの機能が、プールを全部食い潰せてしまう問題です。

船には、隔壁(バルクヘッド)が入っています。 船底に穴が空いても、区画1つが浸水するだけで、船は沈みません。 ソフトウェアでも同じことをします。

「おすすめ」が使っていい同時実行数を、あらかじめ区切っておく。 区切っておけば、その機能が全部おかしくなっても、被害はその区画の中で止まります。

一番小さい実装は、数を数えるだけです。

function createBulkhead(limit) {
  let running = 0;
  return async function run(fn) {
    if (running >= limit) throw new Error(`同時実行の上限 ${limit} に達しています`);
    running++;
    try {
      return await fn();
    } finally {
      running--;      // ⚠️ finally で必ず戻す。ここを忘れると、いつか全部埋まる
    }
  };
}

const recommendBulkhead = createBulkhead(4);   // プール10本のうち、最大4本まで

使うときは、ブレーカのさらに外側です。

const items = await recommendBulkhead(() => recommendBreaker(() => retry(/* ... */)));

これで、/api/recommend に何本殺到しても、同時に走るのは4本までです。残りは即座に失敗します。②の実験をもう一度やっても、DBのプールは6本残ります。

バルクヘッドは、ブレーカが開くまでの「あいだ」を守る道具です。 ブレーカは連続5回失敗するまで開きません。 その5回のあいだに、全部食い潰されては意味がないからです。

⑧ 落ちたことに、自分が気づく

ここまでの仕組みには、共通した副作用があります。

うまく作るほど、壊れていることに気づかなくなります。

おすすめ欄が消えていても、ページは出ます。 利用者は文句を言いません。そして半年後、その機能は死んだままだったと分かります。

だから、監視の回とトレーシングの回が、ここで回収されます。

(1)ログに、状態の変化だけを出す

breaker.js は、すでに console.error / console.warn を書いてあります。 大事なのは書き方です。

出すもの出さないもの
状態が変わった瞬間だけ(閉→開、開→半開、半開→閉)開いているあいだの失敗を毎回

開いているあいだは、1秒に何百回も失敗します。 それを全部ログに出すと、Loki が障害中に一番いらないログで埋まります。 障害中にログが読めなくなるのは、よくある二次災害です。

(2)数えられる形にする

bash
$ sudo journalctl -u myserver@3000 --since "10 min ago" --no-pager | grep -c "breaker.*開"

Prometheus に出すなら、カウンタを1つ増やすだけです。

// prom-client を使っている前提(監視の回で入れたもの)
const breakerOpens = new client.Counter({
  name: "app_breaker_open_total",
  help: "サーキットブレーカが開いた回数",
  labelNames: ["name"],
});
// breaker.js の「開」に移るところで
breakerOpens.inc({ name });

アラートの条件は、これで十分です。

app_breaker_open_total が 5分間で 1 以上増えたら通知する。

(3)トレースに印を付ける

トレーシングの回で入れた自動計装は、呼んでいない処理をスパンにできません。 ブレーカが開いていると、外部呼び出しのスパンが、ある時刻から忽然と消えます。

「スパンが無い」は、目で追うのが難しい異常です。 だから印を付けます。

const { trace } = require("@opentelemetry/api");
trace.getActiveSpan()?.setAttribute("breaker.state", "open");

これで、トレース画面から「このリクエストは、開いていたので呼んでいない」と読めます。

⑨ やりすぎない — これはどこから必要になるのか

ここまで5つの仕組みを入れました。正直に線を引きます。

サーキットブレーカとバルクヘッドは、複数のサービスがあるときの道具です。 アプリが1台で、依存が MySQL と Redis だけなら、タイムアウトだけで十分です。

理由は3つあります。

理由中身
効果が出る条件が「呼び先が複数ある」こと1つしか依存が無いなら、それが落ちたら結局サービスは止まる。 開いても救うものが無い
状態を持つコードは、バグるブレーカはプロセスごとに別の状態を持ちます。2台なら2つの独立したブレーカがあり、片方だけ開きます
開きっぱなしのブレーカは、自作の障害閾値を間違えると、相手は元気なのに呼ばなくなります。 私はこれを実際にやりました(後述)

この記事の中での優先順位

もし1つしか入れないなら、迷わずこれです。

順入れるもの効果
1タイムアウト⭐⭐⭐ これだけで②のカスケード障害は起きません
2外部呼び出しを、DBの接続を持ったままやらない⭐⭐⭐ コストゼロ。書き方の問題だけ
3Promise.allSettled にする(画面の縮退)⭐⭐ 1行
4ジッター付きリトライ⭐ 呼び先が2つ以上になってから
5バルクヘッド⭐ 同上
6サーキットブレーカ⭐ 呼び先が3つ以上になってから

1と2は、いま全員がやるべきです。 3も1行です。4以降は、マイクロサービスの回で書いたとおり「困ってから」で間に合います。

そして、ここまで自分で書いたあとなら、ライブラリを使う判断もできます。 Node.js には opossum という定番があります。中でやっていることは、⑤で書いた30行とほぼ同じです。先に自分で書いたので、設定項目の意味が全部わかります。

Kubernetes やサービスメッシュを入れると、この一部は基盤側でやってくれます。 ただし、基盤がやってくれるのはタイムアウトとリトライまでです。「おすすめ欄を消してページは出す」は、アプリにしか判断できません。

つまずいたところ

1. タイムアウトを入れたのに、/api/stats がまだ死んだ

③で AbortSignal.timeout(800) を入れた直後、まだプールが枯れました。

原因は、knex.transaction を消し忘れていたことでした。タイムアウトを入れたので800msで返るようにはなったのですが、その800msのあいだ、DBの接続を握ったままでした。12本同時なら、0.8秒間だけ、プールは全滅します。

タイムアウトは「握る時間を短くする」だけで、「握らない」にはしてくれません。 一番効くのは、transaction の外に fetch を出したことでした。

この順で確かめると分かります。

bash
$ sudo journalctl -u myserver@3000 --since "2 min ago" --no-pager | grep -c "pool is probably full"

2. 半開のとき、10本まとめて通してしまった

最初に書いたブレーカには trialInFlight がありませんでした。

open から half-open に移ったあと、同時に来た10本が全部「半開だから通す」判定になり、壊れている相手に10本まとめて投げました。 これでは開いていた意味がありません。

[breaker] recommend → 半開(試しに1本だけ通します)
[breaker] recommend → 半開(試しに1本だけ通します)
[breaker] recommend → 半開(試しに1本だけ通します)

「半開」という言葉を、「少し通す」だと読んでいたのが間違いでした。正しくは「1本だけ通して、様子を見る」です。trialInFlight のフラグ1つで直りました。

「回復したかを確かめる」ための試行なのに、確かめる前に全部投げていました。

3. 閾値を 2 にしたら、相手が元気なのにブレーカが開いた

「早く開いたほうが安全だろう」と思って failureThreshold: 2 にしました。

結果、ふだんの運用でブレーカが開くようになりました。 相手は落ちていません。たまたまネットワークが2回続けて詰まっただけです。そのたびに、おすすめ欄が10秒消えました。

ブレーカを敏感にしすぎると、自分で障害を作ります。

5回にしたら止まりました。 決め方は「相手が本当に落ちているなら5回連続で失敗するし、たまたまなら5回は続かない」です。ここは実測で決めるしかありません。

4. slow.js を止め忘れて、ポートが埋まっていた

正常版に差し替えるとき、Ctrl+C を押したつもりで押していませんでした。 新しい slow.js は EADDRINUSE で起動に失敗していたのに、別の窓だったので気づきませんでした。

bash
$ ss -tlnp | grep 3999

トレーシングの回でも、同じ失敗をしています。 「設定したのに効かない」と思ったら、まず自分の変更が本当に動いているかを疑う。3回目です。

後片づけ

slow.js は、必ず止めてください。 3999番を掴んだままになります。

slow.js を動かしているターミナルで Ctrl+C。 残っていないか確認します。

bash
$ ss -tlnp | grep 3999

何も出なければOKです。 出るなら、番号を確認してから止めます。

bash
$ pkill -f "node.*slow.js"
$ ss -tlnp | grep 3999

ディレクトリごと消して構いません。

bash
$ rm -rf ~/slowsvc

/api/recommend は、呼び先が無くなるので必ず 503 を返します。 残しておいても害はありませんが、消すならルートごと消してください。 ブレーカとバルクヘッドの定義も一緒に消します。

クッキーのファイルも消します。

bash
$ shred -u ~/cookie.txt 2>/dev/null || rm -f ~/cookie.txt

cookie.txt にはログイン済みのセッションIDが入っています。 セキュリティ点検の回で書いたとおり、そのまま置いておくと、それだけでログインできてしまいます。

正常に動くことを確認する

止めたものが全部戻っているか、上から順に確かめます。

bash
$ systemctl is-active redis-server mysql nginx myserver@3000 myserver@3001

5つとも active になっていることを確認してください。

bash
$ curl -s -o /dev/null -w "%{http_code} %{time_total}s\n" http://127.0.0.1/
$ curl -s -o /dev/null -w "%{http_code} %{time_total}s\n" http://127.0.0.1:3000/api/health

そして、障害対応の回で覚えた「再起動まで含めて確認する」をやります。

bash
$ sudo reboot

上がってきたら、もう一度 systemctl is-active を打ってください。 active に戻っていなければ、enable されていないだけです(systemd の回)。

[スクリーンショット: 04_degraded_page.png] 再起動後に systemctl is-active を打って、5つとも active が並んでいる画面を撮ってください。

~/server、appdb、~/monitoring は残してください。 続きの回で使います。 nginx に足した proxy_*_timeout と、knex の acquireTimeoutMillis は、残してください。 入れっぱなしで得しかありません。

まとめ

  • 依存は落ちる。 MySQL も Redis も nginx も、すでにネットワーク越しの別プロセスである
  • 「キャッシュは落ちても大丈夫に書いた」は、半分だった。 セッションストアが同じ Redis だった
  • 一番弱い依存は、一番目立たないところにある。 自分で書いた覚えのない場所を疑う
  • 落ちる故障より、「生きているのに返事をしない」故障のほうがずっと怖い
  • タイムアウトが無い呼び出しが1本あると、DBのプール10本が埋まって全滅する(カスケード障害)
  • 外部呼び出しを transaction の中でやらない。 一番希少な資源を、一番遅い処理に握らせない
  • タイムアウトは「遅い相手を切る設定」ではなく「自分の資源がいつ返るかの保証」
  • 値は p95 の3〜4倍。 上から下へ、必ず短くしていく(タイムアウト予算)
  • 素直な3回リトライは、弱った相手に3倍を送りつける(リトライストーム)
  • 指数バックオフは、ジッターとセットでなければほぼ意味がない(Math.random() * backoff)
  • 400番台はリトライしない。 冪等でない POST もリトライしない(Idempotency-Key を付けるなら別)
  • サーキットブレーカは、状態変数3つと if 4つ。 30行で書ける。ライブラリは後でいい
  • 閉=正常。 日本語の直感と逆なので注意
  • 失敗を早く返すのは、①自分を守り ②相手に回復の時間を与え ③利用者を待たせないため
  • ブレーカが外、リトライが内。 逆にすると即失敗を3回やり直す
  • 半開は「少し通す」ではなく「1本だけ通す」。 ここを間違えると開いた意味が消える
  • 閾値を敏感にしすぎると、自分で障害を作る(2回はダメだった。5回で止まった)
  • 縮退は「全部か無か」をやめること。 遅くても返す / 一部を消して返す
  • Promise.all を Promise.allSettled にするだけで、画面は全滅しなくなる
  • 認証を落とす縮退はしない。 在庫や残高に嘘の代替値を返さない。 迷ったら 503
  • 障害のときにしか通らないコードは、障害のときに動かない。 代替の道も常に通しておく
  • バルクヘッドは、ブレーカが開くまでの「あいだ」を守る。 finally で必ずカウンタを戻す
  • うまく作るほど、壊れていることに気づかなくなる。 状態が変わった瞬間だけをログに出す
  • これは呼び先が複数あるときの道具。 1台のうちは、タイムアウトと「transaction の外で呼ぶ」だけで十分

参考リンク


次に読む

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

記事
← 前の記事読んでも消えないキュー — Kafkaとオフセット
→ 次の記事LLMは検索ではない — 埋め込みとRAGを手で書く

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

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

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

Backend/DevOps›Building for Scale
  • サーキットブレーカ / 縮退 / バルクヘッド
  • 可用性 — 1つ落ちても全部は止めない

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

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

コメント

コメントする

目次