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

可用性とSLO。稼働するサーバーとチェックリスト、時計と目標の的。

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

端末を2つ開きます。 VS Code の統合ターミナルを2枚でも、ssh を2本張っても構いません。この記事では「端末1」「端末2」と呼びます。

前回: 結果整合性とCAP定理 — リロードしたら件数が減った

これは【深掘り】の記事です。本線の順路ではありません。 読まなくても先へは進めます。 本線のボトルネックは動く — 負荷分散とキャッシュの設計の回で「冗長化すると落ちにくくなる」と書きました。この記事は、その「落ちにくい」を数字に直すだけの回です。 システム設計深掘りシリーズの続きなので、興味が無ければ飛ばして構いません。

この記事のコマンドは、すべてVMの中(Ubuntu Server)で打ちます。 Windows の PowerShell では打ちません。

本番サイト(obmes.com)を実験に使わないでください。 この記事はわざとサーバーを落として、落ちている間に何%が失敗するかを数える内容です。実際に人が見ているサイトでやると、そのまま本物の障害になります。 実験はすべて、VMの中に立てた練習用の構成に対してだけ行います。

前提: VMに Docker と Docker Compose が入っていること(docker compose version が返ること)。curl と awk が使えること(Ubuntu Server なら最初から入っています)。


自分のサイトの「サービス品質」のページに、こう書こうとしたことがあります。

「稼働率 99.9% を目指します」

書いた時点で、私はそれが何分なのかを知りませんでした。 なんとなく「ほぼ落ちない」くらいの意味で使っていました。9が3つ並んでいて、いかにも立派に見えたからです。

気になって、電卓を叩きました。

1か月は 43200分。その 0.1% は 43.2分。

月に43分しか落ちてはいけない、という意味でした。

これは、私が想像していたものよりはるかに短い時間です。43分というのは、

  • カーネルを更新して再起動するのに、うっかり手こずったら溶ける時間
  • 設定を1行間違えて、原因に気づくまでに溶ける時間
  • 朝起きて、通知に気づいて、パソコンを開くまでに溶ける時間

つまり、「月に1回、原因調査に手間取ったら、その月はもう約束を破っている」ということです。

さらに悪いことに、私はもっと根本的な勘違いをしていました。

このとき私の構成は、ざっくり「回線 → DNS → nginx → アプリ → データベース」でした。それぞれが 99.9% だとして、全体も 99.9% くらいだろうと思っていたのです。

逆でした。

直列に並んだ部品の可用性は、掛け算になります。 99.9% の部品を5つ直列にしたら、全体は 99.5%。年間の停止時間は 8時間45分から 43時間に増えます。

部品を足すと、可用性は必ず下がります。 上がるのは「同じ役割のものを並べたとき」だけです。私は「構成を丁寧に作り込むほど落ちにくくなる」と思っていましたが、作り込むほど直列の鎖が伸びていたわけです。

この記事でやるのは、この2つを手を動かして確かめることです。

  1. 9の数を、分に直す。 感覚で「ほぼ落ちない」と言うのをやめる
  2. 落ちている間に、実際に何%が失敗するかを数える。 「何分落ちたか」ではなく「何件失敗したか」で測る

図を眺めても身に付きません。nginx とバックエンド2台を立てて、1台を止めて、curl を回し続けて数えます。

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

目次

この記事でわかること

  • 99.9% は「月に43分」でしかないこと。9の数は、必ず分に直してから語るものだということ
  • 部品を足すと可用性は下がること(直列は掛け算)。上がるのは同じ役割のものを並べたときだけだということ
  • 可用性は「落ちていた時間」より「失敗したリクエストの割合」で測るほうが実態に合うこと。夜中の10分と昼の10分は、同じ10分ではないこと
  • 1台落ちても、失敗が0件になることがあること。そしてそれは設定次第だということ
  • 復旧までの時間を決めているのは、障害の大きさではなく、ヘルスチェックの間隔だということ
  • 可用性を上げる近道は MTBF(壊れにくさ)ではなく MTTR(直す速さ)だということ
  • SLA と SLO はまったく別のものだということ。SLA は契約で返金の話、SLO は自分たちの目標
  • 個人サイトに 99.99% は要らないこと。どこまで上げるかは、常に金額との交換だということ

この記事でやること

  1. 練習用のディレクトリ ~/avlab を作り、9の数を年・月・週・日の分数に直すスクリプトを書いて実行する
  2. 直列(掛け算)と並列(1-(1-A)^n)を計算するスクリプトを書き、部品を足すと下がることを表で確かめる
  3. nginx + バックエンド2台を Docker Compose で立てる
  4. curl を回し続けて成功・失敗を数えるスクリプトを書き、1台を止めた状態での失敗率を実測する
  5. fail_timeout を変えて、復旧までの時間が変わることを実測する
  6. MTBF / MTTR から可用性を計算し、SLO とエラーバジェットを月43分として残りを出す
  7. 立てたものを全部消す

先に知る言葉

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

言葉意味
可用性(availability)使いたいときに使える割合。 「99.9%」のような数字で表す。残りの 0.1% が、落ちてよい時間
9の数(ナイン)可用性の桁の呼び方。99.9% を「スリーナイン」、99.99% を「フォーナイン」と読む。9が1つ増えると、停止できる時間は10分の1になる
直列1つでも落ちたら全体が止まる繋がり方。回線・DNS・Webサーバー・データベースは、たいてい直列
並列(冗長化)同じ役割のものを複数並べること。全部落ちたときだけ止まる
SLIService Level Indicator。実際に測っている数字そのもの。 「成功率 99.94%」など
SLOService Level Objective。自分たちで決める目標。 「成功率 99.9% 以上にする」。破っても返金は発生しない
SLAService Level Agreement。利用者との契約。 破ると返金や違約金が発生する。SLO より必ず緩く設定する
エラーバジェットSLO を守りながら「失敗してよい量」。 SLO が月 99.9% なら、月43分ぶんが予算。使い切ったら新機能を止めて安定化に回す
MTBFMean Time Between Failures。壊れてから次に壊れるまでの平均時間。 長いほど壊れにくい
MTTRMean Time To Repair(または Recovery)。壊れてから直るまでの平均時間。 短いほど早く直る
fail_timeoutnginx の設定。「落ちている」と判断したサーバーを、何秒間、振り分け先から外すか。 この秒数ごとに再挑戦する
max_failsnginx の設定。何回失敗したら「落ちている」と判断するか

① 練習場所を作る

端末1 で、VMの中に作業用のディレクトリを作ります。

bash
$ mkdir -p ~/avlab
$ cd ~/avlab
$ pwd

/home/<あなたのユーザー名>/avlab と出れば大丈夫です。以降のコマンドは、断りが無いかぎりこのディレクトリで打ちます。

戻し方: この記事で作るものは、すべて ~/avlab の中と Docker のコンテナだけです。最後の「後片づけ」で全部消せます。 VM本体の設定には一切触れません。


② 9の数を、分に直す

まず計算からです。ここを飛ばすと、この記事の残り全部が「なんとなく」になります。

手で1回だけ計算する

1年は 365日 = 525600分です。ここから始めます。

bash
$ echo "1年の分数: $((365 * 24 * 60))"
$ echo "1か月(30日)の分数: $((30 * 24 * 60))"
$ echo "1週間の分数: $((7 * 24 * 60))"
$ echo "1日の分数: $((24 * 60))"

こう出ます。

1年の分数: 525600
1か月(30日)の分数: 43200
1週間の分数: 10080
1日の分数: 1440

43200分。 ここが出発点です。この 0.1% が 43.2分です。

$(( )) は bash の整数計算です。$( で始めたら ) で、$(( で始めたら )) で閉じます。閉じ括弧を1つ忘れると 予期しないファイル終端です で止まります(私は必ず1回はやります)。

表を作るスクリプトを書く

毎回電卓を叩くのは面倒なので、スクリプトにします。

bash
$ cat > ~/avlab/nines.sh <<'SCRIPT'
  #!/bin/bash
  # 可用性(%)を、許される停止時間(分)に直す
  printf "%-10s %12s %12s %12s %12s\n" "可用性" "年" "月(30日)" "週" "日"
  for a in 99 99.9 99.95 99.99 99.999; do
    awk -v a="$a" 'BEGIN{
      d = (100 - a) / 100;
      printf "%-9s%% %11.1f分 %11.1f分 %11.2f分 %11.2f分\n", a, d*525600, d*43200, d*10080, d*1440;
    }'
  done
  SCRIPT
$ chmod +x ~/avlab/nines.sh
$ ~/avlab/nines.sh

<<'SCRIPT' のように、区切り文字を引用符で囲んでいるのが大事です。 囲まないと、中の $a が書き込む前に展開されてしまい、変数の消えた壊れたスクリプトができあがります。

実行するとこう出ます。

可用性                 年     月(30日)            週            日
99       %      5256.0分       432.0分      100.80分       14.40分
99.9     %       525.6分        43.2分       10.08分        1.44分
99.95    %       262.8分        21.6分        5.04分        0.72分
99.99    %        52.6分         4.3分        1.01分        0.14分
99.999   %         5.3分         0.4分        0.06分        0.01分

スクリーンショットを撮ってください: 01_nines_table.png

分では読みにくいので、時分秒に直した表も置いておきます。この表を、9の数を口に出す前に必ず見ます。

可用性呼び方年月(30日)週日
99%ツーナイン3日15時間36分7時間12分1時間40分48秒14分24秒
99.9%スリーナイン8時間45分36秒43分12秒10分5秒1分26秒
99.95%—4時間22分48秒21分36秒5分2秒43秒
99.99%フォーナイン52分34秒4分19秒1分1秒8.6秒
99.999%ファイブナイン5分15秒26秒6秒0.9秒

ここから読み取れることが3つあります。

  • 9が1つ増えるごとに、停止できる時間は10分の1になります。 「もう1つ9を増やす」は、手間が1割増える話ではなく、許容が1割になる話です
  • 99.99% は「月4分」です。 これは人が気づいて対応する時間がありません。 4ナインから先は、人ではなく仕組みが自動で復旧する構成でないと届きません
  • 99.999% は「月26秒」です。 再起動1回で終わります。 個人で目指すものではありません

ここで一番刺さったのはこれです。 「99.9%」と「99.99%」は、見た目は9が1つ違うだけですが、月43分と月4分です。10倍違います。 会話の中で「まあ4ナインくらいで」と軽く言えてしまうのが、そもそも危険でした。


③ 直列と並列を計算する

次に、部品を組み合わせたときにどうなるかです。ここが、私が一番大きく間違えていたところです。

式は2本だけ

繋がり方意味式
直列1つでも落ちたら止まるA1 × A2 × A3 × …
並列(冗長化)全部落ちたときだけ止まる1 - (1-A)^n

直列は掛け算です。 1より小さい数を掛け続けるので、必ず小さくなります。

スクリプトで確かめる

bash
$ cat > ~/avlab/chain.sh <<'SCRIPT'
  #!/bin/bash
  # 使い方: ./chain.sh 0.999
  A=${1:-0.999}
  awk -v A="$A" 'BEGIN{
    printf "部品1つあたりの可用性: %.5f (%.3f%%)\n\n", A, A*100;
    printf "【直列】1つでも落ちたら止まる — 足すほど下がる\n";
    s = 1;
    for (n = 1; n <= 10; n++) {
      s = s * A;
      printf "  %2d個 直列: %10.6f%%   年間停止 %8.1f分\n", n, s*100, (1-s)*525600;
    }
    printf "\n【並列】全部落ちたときだけ止まる — 並べるほど上がる\n";
    for (n = 1; n <= 4; n++) {
      p = 1 - ((1-A) ^ n);
      printf "  %2d台 並列: %10.6f%%   年間停止 %8.1f分\n", n, p*100, (1-p)*525600;
    }
  }'
  SCRIPT
$ chmod +x ~/avlab/chain.sh
$ ~/avlab/chain.sh 0.999

出力です。

部品1つあたりの可用性: 0.99900 (99.900%)

【直列】1つでも落ちたら止まる — 足すほど下がる
   1個 直列:  99.900000%   年間停止    525.6分
   2個 直列:  99.800100%   年間停止   1050.7分
   3個 直列:  99.700300%   年間停止   1575.2分
   4個 直列:  99.600600%   年間停止   2099.2分
   5個 直列:  99.501000%   年間停止   2622.7分
   6個 直列:  99.401499%   年間停止   3145.7分
   7個 直列:  99.302097%   年間停止   3668.2分
   8個 直列:  99.202795%   年間停止   4190.2分
   9個 直列:  99.103592%   年間停止   4711.7分
  10個 直列:  99.004488%   年間停止   5232.6分

【並列】全部落ちたときだけ止まる — 並べるほど上がる
   1台 並列:  99.900000%   年間停止    525.6分
   2台 並列:  99.999900%   年間停止      0.5分
   3台 並列: 100.000000%   年間停止      0.0分
   4台 並列: 100.000000%   年間停止      0.0分

同じ 99.9% の部品でも、繋ぎ方でここまで違います。

1つ3つ5つ10個
直列(年間停止)8時間46分26時間15分43時間43分87時間13分
並列(年間停止)8時間46分ほぼ0ほぼ0ほぼ0

スクリーンショットを撮ってください: 02_chain_result.png

ここで注意が2つあります

1つめ。並列の計算は、理想が入りすぎています。

1-(1-A)^n は「2台が独立に、別々の理由で落ちる」ことを前提にしています。現実にはそうなりません。

  • 2台が同じ物理サーバーの上に載っていたら、その1台が落ちたら両方落ちます
  • 2台が同じ設定ファイルを読んでいたら、設定を間違えた瞬間に両方落ちます
  • 2台が同じデータベースを見ていたら、データベースが落ちたら両方落ちます

「並列にした」と言えるのは、落ちる理由が本当に別のときだけです。 同じVMの中にコンテナを2つ並べても、VMが落ちたら両方落ちます(この記事の実験も、まさにそうです)。

2つめ。冗長化すると、振り分ける係が新しく直列に入ります。

      利用者 → [ロードバランサ] → [app1]
                              → [app2]

app1 と app2 は並列ですが、ロードバランサは直列です。ロードバランサが落ちたら、後ろが何台生きていても全滅します。

だから、冗長化の効果を正しく書くとこうなります。

全体 = ロードバランサの可用性 × ( 1 - (1 - アプリの可用性)^台数 )

ロードバランサが 99.9% なら、アプリを何台並べても、全体は 99.9% を超えません。 振り分ける係より上には行けないのです。

「冗長化すれば上がる」ではありませんでした。 「並列にした部分だけが上がり、その前後に足した部品のぶんは下がる」が正しい理解です。台数を増やす話については3台に振り分けたのに偏る — システム設計深掘りでも触れています。


④ 実験用の構成を立てる

ここから手を動かします。nginx 1台(振り分け係)と、バックエンド2台を Docker Compose で立てます。

バックエンドの中身を作る

バックエンドは、どちらが応答したかが分かればいいので、静的なページを返すだけにします。

bash
$ cd ~/avlab
$ mkdir -p app1 app2
$ echo "APP1 OK" > app1/index.html
$ echo "APP2 OK" > app2/index.html
$ ls -l app1 app2

振り分けの設定を書く

lb.conf を作ります。最初はわざと「落ちたら失敗させる」設定にします。 失敗が見えないと、数えられないからです。

bash
$ cat > ~/avlab/lb.conf <<'CONF'
  upstream backend {
      server app1:80 max_fails=1 fail_timeout=10s;
      server app2:80 max_fails=1 fail_timeout=10s;
  }
  
  server {
      listen 80;
  
      location / {
          proxy_pass http://backend;
          proxy_connect_timeout 1s;
          proxy_read_timeout    2s;
  
          # わざと「別のサーバーに回さない」設定にしている。
          # off にしておかないと、1台落ちても失敗が表に出ない。
          proxy_next_upstream off;
  
          add_header X-Upstream $upstream_addr always;
      }
  }
  CONF
$ cat ~/avlab/lb.conf

proxy_next_upstream off; が、この実験の要です。 これを書かないと nginx は自分でもう1台に回してくれるので、失敗が0件になって何も測れません(あとで実際に外して確かめます)。

Compose ファイルを書く

bash
$ cat > ~/avlab/compose.yaml <<'YAML'
  services:
    app1:
      image: nginx:alpine
      container_name: av-app1
      volumes:
        - ./app1:/usr/share/nginx/html:ro
  
    app2:
      image: nginx:alpine
      container_name: av-app2
      volumes:
        - ./app2:/usr/share/nginx/html:ro
  
    lb:
      image: nginx:alpine
      container_name: av-lb
      ports:
        - "8080:80"
      volumes:
        - ./lb.conf:/etc/nginx/conf.d/default.conf:ro
      depends_on:
        - app1
        - app2
  YAML

:ro は read-only、つまりコンテナから書き換えられないという指定です。設定ファイルを渡すときは付けておきます。

立てて、動いていることを確かめる

bash
$ cd ~/avlab
$ docker compose up -d
$ docker compose ps

3つとも running になっていれば大丈夫です。確かめます。

bash
$ for i in 1 2 3 4; do curl -s http://localhost:8080/; done

こう出れば成功です。

APP1 OK
APP2 OK
APP1 OK
APP2 OK

交互に返っています。 2台に振り分けられている証拠です。

うまくいかないとき – curl: (7) Failed to connect → docker compose ps で av-lb が上がっているか確認。上がっていなければ docker compose logs lb – 502 Bad Gateway → lb.conf の upstream に書いたサービス名(app1 / app2)が compose.yaml のサービス名と一致しているか確認します。Compose のネットワークではサービス名がそのままホスト名になります – ポート 8080 が使用中と言われたら、compose.yaml の "8080:80" を "8081:80" などに変え、以降の 8080 を読み替えてください

この構成そのものについては、本線のポート番号を隠す — nginxのリバースプロキシの回で作ったものと同じ形です。


⑤ 落ちている間に、何%が失敗したかを数える

ここがこの記事の中心です。

「何分落ちたか」ではなく「何件のリクエストが失敗したか」で測ります。 なぜそうするのかは、測ったあとに書きます。

測るスクリプトを書く

bash
$ cat > ~/avlab/probe.sh <<'SCRIPT'
  #!/bin/bash
  # 使い方: ./probe.sh [秒数]
  DURATION=${1:-60}
  URL="http://localhost:8080/"
  
  ok=0
  ng=0
  end=$(( $(date +%s) + DURATION ))
  
  while [ "$(date +%s)" -lt "$end" ]; do
    code=$(curl -s -o /dev/null -w '%{http_code}' --max-time 3 "$URL")
    if [ "$code" = "200" ]; then
      ok=$((ok + 1))
    else
      ng=$((ng + 1))
      echo "$(date +%T)  失敗  code=$code"
    fi
    sleep 0.1
  done
  
  total=$((ok + ng))
  echo "--------------------------------"
  echo "成功 $ok 件 / 失敗 $ng 件 / 合計 $total 件"
  awk -v o="$ok" -v t="$total" 'BEGIN{
    if (t == 0) { print "リクエストが0件です"; exit }
    r = o / t * 100;
    printf "成功率 %.4f%%   (失敗率 %.4f%%)\n", r, 100 - r;
    printf "この成功率が1か月続いた場合の停止相当時間: %.1f分\n", (1 - o/t) * 43200;
  }'
  SCRIPT
$ chmod +x ~/avlab/probe.sh

-o /dev/null -w '%{http_code}' は、「本文は捨てて、HTTPステータスコードだけを出す」という curl の書き方です。成功か失敗かだけを見たいときの定型なので覚えておくと便利です。

--max-time 3 は3秒で諦めるという意味です。 これを付けないと、返ってこないサーバーの前でスクリプトが永遠に止まります。

まず、何も落とさずに測る(基準値)

端末1 で 30秒回します。

bash
$ ~/avlab/probe.sh 30
--------------------------------
成功 249 件 / 失敗 0 件 / 合計 249 件
成功率 100.0000%   (失敗率 0.0000%)
この成功率が1か月続いた場合の停止相当時間: 0.0分

失敗0件。 これが基準です。

1台落として測る

端末1 で測定を始めます。今度は60秒です。

bash
$ ~/avlab/probe.sh 60

すぐに端末2 に移り、app1 を止めます。

bash
$ docker stop av-app1

端末1 を見ていると、こう出ます。

14:32:07  失敗  code=502
14:32:17  失敗  code=502
14:32:27  失敗  code=502
14:32:37  失敗  code=502
14:32:47  失敗  code=502
--------------------------------
成功 493 件 / 失敗 5 件 / 合計 498 件
成功率 98.9960%   (失敗率 1.0040%)
この成功率が1か月続いた場合の停止相当時間: 433.7分

スクリーンショットを撮ってください: 03_one_backend_down.png

ここで、2つ驚いたことがあります。

驚き1: 2台のうち1台が落ちたのに、失敗は50%ではなく1%だった。

素朴に考えれば「交互に振り分けているのだから、半分は app1 に行って失敗するはず」です。そうなりません。

失敗の時刻を見てください。:07、:17、:27、:37、:47 と、ぴったり10秒おきです。これは偶然ではありません。

lb.conf に書いた max_fails=1 fail_timeout=10s がそのまま出ています。

  1. app1 が1回失敗する(max_fails=1)
  2. nginx が app1 を10秒間、振り分け先から外す(fail_timeout=10s)
  3. その10秒間、全部のリクエストは app2 に行く → 全部成功
  4. 10秒経つと、nginx は「もう直ったかもしれない」と1件だけ app1 に流す → また失敗
  5. 2に戻る

つまり、失敗は「10秒に1件」だけです。 残りは全部 app2 が受けています。

驚き2: 失敗率1%は、月432分に相当する。

わずか5件の失敗です。しかしこの割合が1か月続けば、月7時間12分の停止に相当します。99.9%(月43分)にはまるで届きません。

「たった5件」と「月7時間」が同じことを言っているというのが、率で測る意味です。


⑥ ヘルスチェックの間隔が、復旧時間を決めている

さっきの実験で、失敗が10秒おきに出たのは fail_timeout=10s のせいでした。では、これを変えたらどうなるか。

fail_timeout を 60秒にする

bash
$ cp ~/avlab/lb.conf ~/avlab/lb.conf.bak
$ sed -i 's/fail_timeout=10s/fail_timeout=60s/' ~/avlab/lb.conf
$ grep fail_timeout ~/avlab/lb.conf
$ docker compose restart lb

app1 はまだ止まったままなので、そのまま測ります。

bash
$ ~/avlab/probe.sh 60
14:41:03  失敗  code=502
--------------------------------
成功 497 件 / 失敗 1 件 / 合計 498 件
成功率 99.7992%   (失敗率 0.2008%)
この成功率が1か月続いた場合の停止相当時間: 86.7分

失敗が1件になりました。 60秒に1回しか試さないので当然です。

fail_timeout を 2秒にする

bash
$ sed -i 's/fail_timeout=60s/fail_timeout=2s/' ~/avlab/lb.conf
$ grep fail_timeout ~/avlab/lb.conf
$ docker compose restart lb
$ ~/avlab/probe.sh 60
成功 470 件 / 失敗 28 件 / 合計 498 件
成功率 94.3775%   (失敗率 5.6225%)

失敗が28件に増えました。 2秒に1回試すので、当然です。

3つを並べる

fail_timeout60秒間の失敗失敗率落ちた app1 が復旧したとき、戻るまでの最大時間
2秒28件5.6%2秒
10秒5件1.0%10秒
60秒1件0.2%60秒

ここが重要な逆転です。

  • fail_timeout を長くすると、落ちている間の失敗は減ります
  • しかし、直ったときに戻ってくるのが遅くなります

確かめます。fail_timeout=60s に戻して、app1 を復旧させてみます。

bash
$ sed -i 's/fail_timeout=2s/fail_timeout=60s/' ~/avlab/lb.conf
$ docker compose restart lb

端末1 で監視します(どちらが返しているかを見ます)。

bash
$ for i in $(seq 1 90); do
$   printf "%s " "$(date +%T)"
$   curl -s http://localhost:8080/
$   sleep 1
$ done

数秒待ってから、端末2 で app1 を戻します。

bash
$ docker start av-app1

端末1 の出力を見ると、こうなります。

14:50:11 APP2 OK
14:50:12 APP2 OK
14:50:13 APP2 OK
      ...  app1 は起動済みなのに、ずっと APP2 だけが返る
14:51:04 APP2 OK
14:51:05 APP1 OK
14:51:06 APP2 OK

app1 のコンテナは 14:50:13 には起動していました。 それなのに振り分けが戻ったのは 14:51:05。52秒間、直っているのに使われていませんでした。

これが「復旧時間はヘルスチェックの間隔で決まる」ということです。 障害が直った瞬間から実際に戻るまでの時間は、たいてい「直す時間」ではなく「気づく間隔」です。

どちらに振るかは、そのままトレードオフです。

間隔を短くする間隔を長くする
落ちている間の失敗増える減る
直ってから戻るまで速い遅い
バックエンドへの負荷増える減る
向いている場面すぐ直る障害が多い(再起動・デプロイ)長引く障害が多い(ハード故障)

nginx のオープンソース版には能動的なヘルスチェック(定期的に /health を叩きに行く機能)はありません。 上でやっているのは「本物のリクエストが失敗したかどうか」で判断する受動的なやり方(max_fails / fail_timeout)です。だから必ず、誰かのリクエストが1件は犠牲になります。

能動的なヘルスチェックが使える環境(Kubernetes の readinessProbe、クラウドのロードバランサ、nginx の商用版)では、利用者のリクエストを犠牲にせずに外せます。 これが「4ナインは人ではなく仕組みで取る」という話の中身です。

そして、失敗を0にする設定がある

最初にわざと入れた proxy_next_upstream off; を、別の値に書き換えます。

bash
$ sed -i 's/proxy_next_upstream off;/proxy_next_upstream error timeout http_502 http_503 http_504;/' ~/avlab/lb.conf
$ grep proxy_next_upstream ~/avlab/lb.conf
$ docker compose restart lb

app1 をもう一度落として、測ります。

bash
$ docker stop av-app1
$ ~/avlab/probe.sh 60
--------------------------------
成功 498 件 / 失敗 0 件 / 合計 498 件
成功率 100.0000%   (失敗率 0.0000%)
この成功率が1か月続いた場合の停止相当時間: 0.0分

失敗0件です。バックエンドの半分が落ちているのに、利用者から見た可用性は 100% です。

proxy_next_upstream は「振り分け先が失敗したら、同じリクエストを別のサーバーにやり直す」という設定です。app1 で 502 になっても、nginx が黙って app2 に投げ直すので、利用者にはエラーが返りません。

これが冗長化の本当の効き目です。 「2台あるから半分は生きている」ではなく、「失敗したことを利用者に見せない」ことが目的でした。

ただし、これは無条件には使えません。

  • やり直して安全なリクエストにしか使えません。 GET は何度やっても同じですが、「決済する」を2回投げたら二重決済です。nginx はデフォルトでは non_idempotent を対象に含めないので POST はやり直しませんが、設定次第で危険になります
  • やり直しは待ち時間を増やします。 1台目で 1秒待ってから2台目に行けば、その利用者は2倍待たされます
  • 全部落ちていたら、やり直しても失敗します。 当たり前ですが、これは冗長性そのものの代わりにはなりません

⑦ MTBF と MTTR — 上げやすいのはどちらか

可用性は、時間の割合としてもう1つの書き方ができます。

可用性 = MTBF / (MTBF + MTTR)
  • MTBF(Mean Time Between Failures)= 壊れてから次に壊れるまでの平均
  • MTTR(Mean Time To Repair)= 壊れてから直るまでの平均

計算スクリプトを作ります。

bash
$ cat > ~/avlab/mttr.sh <<'SCRIPT'
  #!/bin/bash
  # 使い方: ./mttr.sh <MTBF時間> <MTTR分>
  MTBF_H=${1:-720}
  MTTR_M=${2:-60}
  awk -v b="$MTBF_H" -v r="$MTTR_M" 'BEGIN{
    bm = b * 60;
    a  = bm / (bm + r);
    printf "MTBF %.0f時間 (%.0f分) / MTTR %.0f分\n", b, bm, r;
    printf "→ 可用性 %.5f%%\n", a * 100;
    printf "→ 年間停止 %.1f分 / 月間停止 %.1f分\n", (1-a)*525600, (1-a)*43200;
  }'
  SCRIPT
$ chmod +x ~/avlab/mttr.sh

基準として、「月に1回落ちて、直すのに1時間かかる」を入れます。

bash
$ ~/avlab/mttr.sh 720 60
MTBF 720時間 (43200分) / MTTR 60分
→ 可用性 99.86130%
→ 年間停止 729.0分 / 月間停止 59.9分

月60分の停止。99.9%(月43分)に届いていません。

ここから、2つの改善の道を比べます。

道A: 壊れにくくする(MTBF を2倍に = 2か月に1回しか落ちない)

bash
$ ~/avlab/mttr.sh 1440 60
→ 可用性 99.93060%  年間停止 364.7分  月間停止 30.0分

道B: 早く直す(MTTR を半分に = 30分で直す)

bash
$ ~/avlab/mttr.sh 720 30
→ 可用性 99.93060%  年間停止 364.7分  月間停止 30.0分

数字はまったく同じです。 式を見れば当たり前で、どちらも比を2倍にしているだけだからです。

では何が違うのか。「やりやすさ」がまるで違います。

MTBF を2倍にするMTTR を半分にする
何をするか落ちる原因を1つずつ潰す気づく・切り替える・戻す を速くする
必要なものテスト、冗長なハード、枯れた構成、時間監視・通知・手順書・ロールバック
効果が出るまで数か月〜(落ちた回数でしか測れない)その日から
効果の測り方落ちないと測れない(≒測りにくい)障害のたびに測れる
上限0にはできない(ハードは壊れる、人は間違える)数秒まで縮められる(自動切り替え)

上げやすいのは MTTR です。 「壊れないようにする」には限界があります。 ハードは壊れ、回線は切れ、人は設定を間違えます。 一方で「早く直す」には、まだ伸びしろが残っています。 気づくのが5分早ければ、それはそのまま5分の停止削減です。

MTTR を縮めるためにやることは、可用性の話というより手順の話です。

  1. 落ちたことに気づく(Prometheusは取りに行く — 監視とログの入口)
  2. どこが落ちたか切り分ける(障害対応は切り分けの順番がすべて — わざと壊して直す)
  3. 戻す(切り替える、前のバージョンに戻す)
  4. 落ちた部分だけ切り離して、残りは動かし続ける(落ちても全部は止めない — サーキットブレーカと縮退)

「戻し方を先に用意しておく」が、可用性を上げる一番安い方法でした。冗長化はお金がかかりますが、手順書は無料です。


⑧ SLA / SLO / SLI とエラーバジェット

ここまで数字を出してきたので、その数字の呼び分けを整理します。この3つを混ぜて話すと、必ず揉めます。

何か誰が決めるか破ったらどうなるか
SLI実際に測った数字。 「先月の成功率は 99.94% だった」測定が決める—
SLO自分たちの目標。 「成功率 99.9% 以上」自分たち内部の話。 開発を止めて安定化に回す
SLA利用者との契約。 「99.5% を下回ったら返金」契約お金が動く(返金・違約金)

順番は必ずこうなります。

SLA  99.5%   ← 契約。破ると返金。一番ゆるい
SLO  99.9%   ← 自分たちの目標。ここを破っても返金はない
SLI  99.94%  ← 実測値。SLO を上回っていれば健康

SLA と SLO を同じ数字にしてはいけません。 そうすると「目標を1回外した瞬間に契約違反」になります。SLO は SLA より厳しくしておいて、SLA に届く前に気づくための緩衝です。

エラーバジェットを計算する

SLO が 99.9% なら、月に 43分は落ちてよい。 この 43分は、我慢する量ではなく、使ってよい予算です。

bash
$ cat > ~/avlab/budget.sh <<'SCRIPT'
  #!/bin/bash
  # 使い方: ./budget.sh <SLO%> <今月すでに使った分>
  SLO=${1:-99.9}
  USED=${2:-0}
  awk -v s="$SLO" -v u="$USED" 'BEGIN{
    b = (100 - s) / 100 * 43200;
    printf "SLO %.3f%% → 今月のエラーバジェット %.1f分\n", s, b;
    printf "使用済み %.1f分 / 残り %.1f分\n", u, b - u;
    if (b > 0) printf "残り %.1f%%\n", (b - u) / b * 100;
    if (b - u < 0)            print "→ 予算超過。新しい変更を止めて、まず落ちない状態に戻す";
    else if ((b-u)/b < 0.25)  print "→ 残りわずか。危ないデプロイは今月やらない";
    else                      print "→ 余裕あり。リスクのある変更を試してよい";
  }'
  SCRIPT
$ chmod +x ~/avlab/budget.sh

月初め、まだ何も落ちていないとき。

bash
$ ~/avlab/budget.sh 99.9 0
SLO 99.900% → 今月のエラーバジェット 43.2分
使用済み 0.0分 / 残り 43.2分
残り 100.0%
→ 余裕あり。リスクのある変更を試してよい

カーネル更新の再起動で12分止めたあと。

bash
$ ~/avlab/budget.sh 99.9 12
使用済み 12.0分 / 残り 31.2分
残り 72.2%
→ 余裕あり。リスクのある変更を試してよい

さらに設定ミスで25分止めたあと(合計37分)。

bash
$ ~/avlab/budget.sh 99.9 37
使用済み 37.0分 / 残り 6.2分
残り 14.4%
→ 残りわずか。危ないデプロイは今月やらない

参考に、SLO を1つ上げるとどうなるか。

bash
$ ~/avlab/budget.sh 99.99 12
SLO 99.990% → 今月のエラーバジェット 4.3分
使用済み 12.0分 / 残り -7.7分
残り -177.8%
→ 予算超過。新しい変更を止めて、まず落ちない状態に戻す

「カーネル更新の再起動1回」で、4ナインの予算は吹き飛びます。

これがエラーバジェットの使い方です。 「もう1回大きめの障害を起こしたら SLO を割る」が、残り6分という具体的な数字で見えます。 「今月はもう冒険しない」という判断が、感覚ではなく数字でできます。

時間で数えるか、リクエストで数えるか

⑤ で、「何分落ちたか」ではなく「何件失敗したか」で測りました。 その理由がここに繋がります。

測り方どう数えるか弱点
時間ベース落ちていた分数を足す深夜の10分と昼の10分が同じ扱い。 誰も見ていない時間の障害を過大評価する
リクエストベース失敗した件数 ÷ 全件数アクセスがゼロの時間帯は分母に入らない。 実害に近い

個人サイトほど、この差は大きくなります。 深夜3時に10分落ちても、その間のアクセスが0件なら、リクエストベースでは失敗率0%です。 「誰も困っていない」という実態と一致しています。

時間ベースの数字だけを見ていると、誰も困っていない障害に必要以上の対策を打つことになります。

ただしリクエストベースにも罠があります。 アクセスが少ないと、1件の失敗が率を大きく動かします。 月に1000件しかアクセスが無いサイトでは、1件失敗しただけで 99.9% です。 分母が小さいときは、率だけでなく件数も一緒に見ます。


SLA を実物で見たいなら、VPS の約款が手近な教材になります。たとえばクラウド VPS byGMOは全プランに月間稼働率 99.99% の SLA を付けていますが、この記事の計算どおり 99.99% は月に約 4 分で、何を「落ちた」と数えるか(SLI)は約款側の定義次第です。料金は 1GB プランで 12 ヶ月契約 月額 858 円(税込・2026-11 時点)に、別途サーチャージ費が毎月かかります。

⑨ 利用者から見た可用性と、サーバーから見た可用性はズレる

最後に、一番見落としやすいところです。

~/avlab/probe.sh は、VMの中から localhost:8080 を叩いていました。 これで測れているのは「nginx とバックエンドが動いているか」だけです。

利用者は、そこに辿り着くまでに、もっとたくさんのものを通ります。

利用者の端末
  → 家の回線 / モバイル回線
    → DNS(名前を引く)
      → CDN
        → 自分のサーバーの回線
          → nginx
            → アプリ
              → データベース

これは全部、直列です。 ③ でやった掛け算がそのまま効きます。

部分誰が持っているか落ちたら
DNSドメイン業者・DNSサービスサイトに辿り着けない。 サーバーは元気
証明書の期限自分HTTPS が繋がらない。 サーバーは元気
CDNCDN業者キャッシュが返せない。 サーバーは元気
レンタルサーバー / VPS の回線業者全部止まる
nginx / アプリ / DB自分止まる

私が過去に一番長く「落ちて」いたのは、サーバーが止まったときではありませんでした。

証明書の更新に失敗して、HTTPS が繋がらなくなっていたときです。 サーバーは元気に動いていて、監視も全部「緑」でした。VMの中から curl http://localhost を叩くと、200 が返っていたからです。

中から測ると、外から見た障害は見えません。

だから、可用性を測るなら外から測ります。

bash
$ curl -s -o /dev/null -w '結果=%{http_code} 名前解決=%{time_namelookup}s 接続=%{time_connect}s TLS=%{time_appconnect}s 合計=%{time_total}s\n' https://obmes.com/
結果=200 名前解決=0.021s 接続=0.043s TLS=0.112s 合計=0.198s

time_namelookup と time_appconnect が分かれて出ているのが大事です。 DNS が遅い・TLS が失敗する、といった「サーバーの外」の問題が、ここで初めて見えます。

本番サイトに対しては、確認のために数回叩くだけにしてください。 ⑤ でやったようなループでの連打はしないでください。 自分のサイトであっても、レンタルサーバー側から異常なアクセスと見なされてIPを遮断されることがあります。 負荷をかける実験は、必ずVMの中の練習用構成に対してだけ行います。

計画停止をどう数えるか

もう1つ、揉めやすいところです。「更新のために予告して止めた時間」は、停止に数えるか。

立場数え方言い分
契約(SLA)たいてい数えない予告した計画メンテナンスは対象外、と契約に書いてある
利用者数える使いたいときに使えなかったことに変わりはない

この2つは食い違います。 そして、利用者の言い分のほうが実態に近いです。

「計画停止は SLA の対象外」は契約上の話であって、利用者の体験ではありません。 SLO(自分たちの目標)では、計画停止も数えることをおすすめします。 そうすると「止めずに更新する方法」を探す動機が生まれます。バックエンドを1台ずつ入れ替えるやり方は、まさに④で立てた構成でそのまま試せます。

で、どこまで上げるのか

上げる方法はあります。問題は値段です。

目標何が要るかざっくり月額誰のためのものか
99%(月7時間)VPS 1台。 落ちたら自分で気づいて直す数百〜千円個人の学習サイト・ポートフォリオ
99.9%(月43分)監視と通知。 深夜でも気づける。戻す手順がある千〜数千円個人の本気のサービス
99.95%(月21分)サーバー2台 + ロードバランサ。 自動で切り替わる数千〜1万円台小規模な商用サービス
99.99%(月4分)複数のデータセンター。 DBも冗長。自動復旧。当番制数万円〜人が対応していては間に合わない領域
99.999%(月26秒)地理的に分散。全部自動。専任の人数十万円〜決済・通信インフラ

9を1つ増やすたびに、費用はだいたい一桁上がります。 そして得られるのは、停止時間が 1/10 になることだけです。

判断は、この1問で決まります。

「1時間止まったら、いくら損するか」

  • 損失がほぼ0円(学習サイト・ポートフォリオ) → 99% で十分。 冗長化にお金を払う理由がありません
  • 1時間で数千円 → 99.9%。 監視だけ入れて、自分で早く直せる状態にする
  • 1時間で数十万円 → 99.99%。 ここで初めて、複数台と自動切り替えが元を取ります

個人サイトに 99.99% は要りません。 月4分を守るために、複数台構成を組んで、当番を決めて、深夜に叩き起こされる仕組みを作る——その労力を記事を書くほうに使ったほうが、確実に価値があります。

そして最悪なのは、「99.99%」と口では言いながら、監視も戻し方も用意していない状態です。 それは 99.99% ではなく、測っていないだけです。 測っていない可用性は、可用性ではありません。


VM の中からの probe は、自分のネットワークの外で起きている失敗を数えられません。外から測る足場が欲しいときは、さくらのVPSのように東京・大阪・石狩からリージョンを選べる VPS を 1 台借り、そこから同じ probe.sh を回す方法があります。512MB プランなら月払い 643〜698 円(税込・リージョンで異なる、2026-11 時点)で、クレジットカード払いなら 2 週間無料で試せます(最低利用期間は 3 ヶ月)。

つまずいたところ

1. ヒアドキュメントの区切り文字を引用符で囲まず、変数の消えたスクリプトができた

cat > x.sh <<SCRIPT(引用符なし)で書くと、中の $ok や $(date) が、ファイルに書き込む前に展開されます。 できあがったスクリプトは変数が空文字に置き換わっていて、実行しても何も起きませんでした。中身をそのまま書きたいときは必ず <<'SCRIPT' と引用符で囲みます。 確かめ方は cat ~/avlab/probe.sh で、$ok がそのまま残っているかを見ることです。

2. curl にタイムアウトを付けず、スクリプトが固まった

app1 を docker stop ではなく docker pause で止めたとき、接続は受け付けるのに応答が返らない状態になりました。--max-time が無いと curl はそこで待ち続け、60秒のはずの測定が10分経っても終わりません。 「落ちる」には繋がらないと繋がるが返ってこないの2種類があり、後者のほうが厄介です。測るスクリプトには必ずタイムアウトを付けます。

3. 「2台のうち1台落ちたら失敗率50%」だと思っていた

実測は 1% でした。nginx が落ちたサーバーを一定時間、振り分け先から外すからです。負荷分散は「毎回全台に均等に振る」ものではなく、「駄目なやつを外す」ものでもあると分かっていませんでした。頭の中の絵と、実際の挙動が違っていたところです。

4. docker start したのに、いつまでも振り分けが戻らなかった

「戻す操作が失敗した」と思って docker logs を何度も見ました。何も間違っていませんでした。 fail_timeout=60s にしていたので、nginx が次に試すまで最大60秒待っていただけです。「直したのに直らない」の相当数は、直っていないのではなく、まだ気づかれていないだけでした。

5. proxy_next_upstream を切っていなかったため、実験そのものが成立しなかった

最初、この設定を書かずに実験を組み立てて、app1 を落としても失敗が0件になり、「測り方が間違っている」と30分ほど悩みました。間違っていたのは測り方ではなく、期待のほうです。 nginx はデフォルトで別のサーバーにやり直します。「失敗を見せない」が正常動作でした。失敗を数える実験をするには、まずその親切を切る必要があると気づくのに時間がかかりました。

6. 中から測って「100%」だと思い込んでいた

localhost を叩く監視は、証明書の期限切れも、DNS の障害も、回線の切断も、まったく検出しません。 全部「緑」のまま、外からは繋がっていない状態が起こりえます。監視は、利用者と同じ経路で外から叩かないと意味がないというのが、この記事で一番効いた学びでした。

7. awk のべき乗が環境によって書き方が違う

1-(1-A)^n の ^ は、Ubuntu の標準(mawk)でも gawk でも動きます。ただし環境によっては ** を使う必要があります。 動かないときは ^ を ** に置き換えて試してください。この記事の chain.sh は、Ubuntu Server の素の状態で動くことを確認しています。

8. sed -i で設定を書き換えていたら、今どの値なのか分からなくなった

fail_timeout を 10s → 60s → 2s と sed -i で書き換えていたら、現在値が分からなくなりました。 書き換えたら必ず grep fail_timeout ~/avlab/lb.conf で確認します。sed -i は元に戻せません。 大事な設定なら、記事中でやったように cp lb.conf lb.conf.bak を先に取ります。


後片づけ

この記事で立てたものを全部消します。

bash
$ cd ~/avlab
$ docker compose down
$ docker compose ps

docker compose ps に何も出なければ、コンテナは消えています。まだ止めていないコンテナが残っていないかも確認します。

bash
$ docker ps -a | grep av-

何も出なければ大丈夫です。

イメージも消したい場合(他で nginx:alpine を使っていないことを確認してから)。

bash
$ docker image rm nginx:alpine

ディレクトリごと消す場合です。

bash
$ cd ~
$ rm -rf ~/avlab
$ ls ~ | grep avlab

rm -rf は取り消せません。 打つ前に、パスが ~/avlab になっていることを必ず目で確認してください。

残しておくなら、nines.sh chain.sh mttr.sh budget.sh の4つはこの先も使います。 消す前に、どこか別の場所に取っておくと便利です。

bash
$ mkdir -p ~/bin
$ cp ~/avlab/nines.sh ~/avlab/chain.sh ~/avlab/mttr.sh ~/avlab/budget.sh ~/bin/
$ ls ~/bin

まとめ — 理解できたこと

  • 9の数は、必ず分に直してから語る。 99.9% は月43分。 「ほぼ落ちない」という感覚は、43分という数字にはまるで足りていなかった
  • 9が1つ増えると、許される停止時間は10分の1になる。 99.9%(月43分)と 99.99%(月4分)は、見た目は9が1つ違うだけで、中身は10倍違う
  • 直列は掛け算。部品を足すと可用性は必ず下がる。 99.9% を5つ直列にすると 99.5%(年8時間45分 → 年43時間43分)
  • 上がるのは、同じ役割のものを並べたときだけ(1 - (1-A)^n)。しかも、振り分ける係が新しく直列に入る。 全体はロードバランサの可用性を超えられない
  • 並列の計算は理想が入っている。 同じVM・同じ設定ファイル・同じDBを共有していたら、それは並列ではない
  • 「何分落ちたか」より「何%のリクエストが失敗したか」のほうが実態に近い。 深夜の10分と昼の10分は同じ10分ではない。ただしアクセスが少ないと1件で率が大きく動くので、件数も一緒に見る
  • 2台のうち1台落ちても、失敗率は50%にならなかった。実測は1%。 nginx が落ちたサーバーを一定時間、振り分け先から外すため
  • 失敗が何件出るかを決めていたのは、障害の大きさではなく fail_timeout だった。 短くすると失敗は増えるが復旧は速く、長くすると失敗は減るが復旧は遅い
  • 「直ったのに戻らない」時間は、ヘルスチェックの間隔そのもの。 fail_timeout=60s では、直っているのに52秒使われなかった
  • proxy_next_upstream を入れると、半分落ちていても失敗0件にできる。 冗長化の目的は「半分生きている」ではなく「失敗を利用者に見せない」こと。ただしやり直して安全なリクエストにしか使えない
  • 可用性 = MTBF / (MTBF + MTTR)。式の上では両方等価だが、上げやすいのは MTTR。 壊れにくくするのは時間がかかり上限があるが、早く直すのはその日から効く
  • 戻し方を先に用意しておくのが、可用性を上げる一番安い方法。 冗長化にはお金がかかるが、手順書は無料
  • SLA・SLO・SLI は別物。SLA は契約で返金の話、SLO は自分たちの目標、SLI は実測値。 SLA と SLO を同じ数字にすると、目標を1回外した瞬間に契約違反になる
  • エラーバジェットは「我慢する量」ではなく「使ってよい予算」。 月43分のうち37分使ったら残り6分、という数字で「今月はもう冒険しない」を決められる
  • 中から測った可用性は、外から見た可用性ではない。 証明書切れも DNS 障害も、localhost を叩く監視には映らない。測っていない可用性は、可用性ではない
  • 個人サイトに 99.99% は要らない。 判断は「1時間止まったら、いくら損するか」の1問で決まる。9を1つ増やすたびに費用は一桁上がり、得られるのは停止時間が 1/10 になることだけ

参考リンク


次に読む

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

記事
← 前の記事結果整合性とCAP定理 — リロードしたら件数が減った
→ 次の記事指数バックオフとバルクヘッド — リトライが障害を長引かせる

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

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

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

System Design›System Design — Availability
  • 99.9% は月43分
  • MTBF より MTTR を縮める

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

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

コメント

コメントする

目次