ロードバランサとオートスケール — 台数を増やしたのに全部落ちる

ロードバランサとオートスケール。負荷分散を表す部品と3台のサーバー、稼働確認のアイコン。

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

台数を増やしたのに全部落ちることがあります。ロードバランサとオートスケールの判定を、実際に動かして確かめます。

前回: EBSの仕組みとボリューム選び — EC2を消したのに課金が続いた

これは【深掘り】の記事です。本線の順路ではありません。 本線の EC2は立てて壊す教材 — AWSの最初の1台 で立てた1台を、 何台にも増やしたときに何が起きるかを、ここで掘ります。飛ばしても本線は進めます。

このシリーズは、読者にアカウントを作らせません。 触るのは LocalStack と、aws CLI の --endpoint-url だけです。 課金が発生する操作は一切しません。 料金は具体的な金額を書きません(変わるため)。 何に対して課金されるかという構造だけを書き、数字は ELB の料金ページと EC2 の料金ページを見てください。 コマンドは VM の中(Ubuntu Server)で打ちます。 最後に docker compose down -v まで全部消します。 そして先に正直に書きます。LocalStack のコミュニティ版では、この記事で扱う API の大半が「作れるけれど動かない」です。 だからこの記事は2本立てです。前半で設定の形を確かめ、後半で同じ考え方を nginx と Node.js で手元に再現して実測します。 なお LocalStack は2026年3月23日から1つのイメージに統合され、それ以降の版(2026.03.0 以降)は起動に auth token(LocalStack のアカウントで取得。無料プランあり)が必要になりました。 この記事では、統合前に公開されて更新が止まった localstack/localstack:3 を固定して使い、アカウントを作らずに進めます。旧イメージの固定は練習用の短期的な手段です(公式は、更新が来ない・修正済みの脆弱性が残ると注意しています)。新しい版を使う場合は、取得した token を LOCALSTACK_AUTH_TOKEN 環境変数に設定します。


「1台だと落ちたら終わりだから、3台にしよう」

そう考えて、練習用のアプリを3台に増やしました。前に立てた nginx をロードバランサにして、後ろに Node.js を3つ並べました。 ポート番号を隠す — nginxのリバースプロキシ でやったことの、後ろが増えただけです。

負荷をかけました。

[1台のとき]  少し遅い。でも返る。
[3台のとき]  最初は速い。しばらくして — 全部 502。

1台のときは「遅い」で済んでいたものが、3台にしたら「全滅」になりました。

意味が分かりませんでした。冗長化したはずなのに、冗長化する前より悪くなっている。

原因を突き止めるのに、丸一日かかりました。ヘルスチェックのパスを / にしていたからです。

/ は、DB を見に行く重い画面でした。 負荷が上がる → / が遅くなる → ヘルスチェックがタイムアウトする → ロードバランサが「この台は死んでいる」と判断する → 切り離す → 残った台に負荷が集中する → その台も / が遅くなる → 切り離す → 以下同文。

台数を増やしたことが、全滅を早めていました。

この記事は、その1日を短くするために書きます。

「ロードバランサを置けば分散される」「オートスケールを入れれば落ちない」というふわっとした期待を、全部いったん疑います。

分散も自動復旧も、設定した数字のとおりにしか動きません。 その数字を、手を動かして測ります。


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

目次

この記事でわかること

  • ELB には3種類ある。 ALB は L7(HTTP の中身を見る)、NLB は L4(TCP だけ)。個人開発ではほぼ ALB でいいこと
  • ロードバランサは「生きている台」に流すのではない。 「ターゲットグループが健康だと言っている台」にしか流さないこと
  • ヘルスチェックの間隔と失敗回数の掛け算が、そのまま「エラーが返り続ける秒数」になること。実測すると 90 秒 と 8 秒の差がつく
  • 短くしすぎると、一時的に遅いだけの台を切ってしまうこと。これも実測で出る
  • ヘルスチェックのパスを / にしてはいけないこと。負荷が上がると全台が同時に異常判定されて全滅する
  • Auto Scaling Group は「最小 / 希望 / 最大」の3つの数で動くこと。手でインスタンスを消しても勝手に復活する
  • スケールアウトは急な負荷に間に合わないこと。起動からヘルスチェック通過まで、分の単位でかかる
  • 負荷が読めるなら固定台数のほうが安くて単純であること。オートスケールの本当の価値は「壊れた台の自動入れ替え」であること
  • nginx のオープンソース版には、ALB のような能動的ヘルスチェックが無いこと(正直に書きます)

この記事でやること

  1. ~/awslab/asg を作り、LocalStack を立てる
  2. ALB・ターゲットグループ・Auto Scaling Group を CLI で作り、設定の形を確かめる(動かない部分は正直に書きます)
  3. 同じ構成を nginx + Node.js 3台で手元に再現する
  4. 1台を落として「何秒エラーが返るか」を、間隔と失敗回数を変えて実測し、表にする
  5. ヘルスチェックを「浅い版」と「深い版」の両方で実装し、負荷時に全滅する様子を実測する
  6. スケーリングポリシー4種と、スケールアウトにかかる時間を分解する
  7. 「そもそもオートスケールが要るのか」の判断表を作る
  8. docker compose down -v まで後片づけする

先に知る言葉

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

言葉意味
ELBElastic Load Balancing。AWS のロードバランサ群の総称
ALBApplication Load Balancer。HTTP の中身(パス・ホスト名)を見て振り分ける
NLBNetwork Load Balancer。TCP のポートしか見ない。中身は見ない
ターゲットグループ振り分け先の台をまとめた箱。ヘルスチェックはここに設定する
ヘルスチェック「この台は生きているか」を定期的に確かめる仕組み
正常しきい値何回連続で成功したら「復活」と見なすか
異常しきい値何回連続で失敗したら「死んだ」と見なすか
ASGAuto Scaling Group。台数を自動で保つ・増減させる仕組み
起動テンプレート「増やすときに、どんな台を作るか」の設計図
希望容量「いま何台か」ではなく「何台にしたいか」。ASG はこの数に寄せ続ける
クールダウン一度増やしたあと、しばらく次の増減を我慢する時間
ウォームアップ増やした台が「使える」と数えられるまでの猶予時間

① ELB の3種類 — 個人開発ではほぼ ALB

AWS のコンソールでロードバランサを作ろうとすると、最初に3択が出ます。

ここで固まる人が多いはずです。私は固まりました。

3種類の対比

ALBNLBGWLB
正式名Application Load BalancerNetwork Load BalancerGateway Load Balancer
OSI の層L7(アプリケーション層)L4(トランスポート層)L3(ネットワーク層)
何を見るかHTTP のパス・ホスト名・ヘッダIP とポートだけ。中身は見ないパケットそのもの
扱えるものHTTP / HTTPS / gRPC / WebSocketTCP / UDP / TLSすべて(透過)
パスで振り分けできる(/api は別の台へ、など)できないできない
固定 IPもらえない(DNS 名で使う)もらえる—
速さ中身を見るぶん少し遅い速い—
主な用途Web アプリ全般ゲーム・独自プロトコル・極端な低遅延セキュリティ機器を挟むとき
個人開発ではこれほぼ要らないまず要らない

迷ったら ALB です。 HTTP のアプリを載せているなら、それ以外を選ぶ理由がありません。 NLB を選ぶのは「HTTP じゃないものを流す」か「固定 IP が絶対に要る」ときだけです。

これは本線でやった話がそのまま出てくる

「L4 と L7 の違い」は、本線の L4とL7の違いは中身を見るか — OSI参照モデル でやりました。

あそこで「層」として抽象的に学んだものが、ここでは商品名になって出てきます。

L7 を見る  →  ALB  →  「/api で始まるリクエストは、別のグループへ」ができる
L4 だけ見る →  NLB  →  「3306 番に来たものを、後ろの3台へ」しかできない

中身を見ないから NLB は速い。中身を見るから ALB は賢い。 それだけの話でした。

層の話は暗記するものではなくて、「どこまで見えているか」という制約の話だと、ここで初めて腑に落ちました。

なお、この記事では「振り分け先をどう選ぶか」(ラウンドロビンか、最小接続数か)は扱いません。 扱うのは「振り分け先から、どうやって死んだ台を外すか」のほうです。

何に課金されるかの構造

金額は書きません。 変わりますし、リージョンで違います。「何に対して課金されるか」の構造だけを書きます。

課金の対象意味
時間ロードバランサが存在している時間。リクエストが0でも課金される
処理量新規接続数・処理したバイト数・ルールの評価回数などを合成した単位
後ろの台ロードバランサとは別に、EC2 の台数ぶんかかる

一番ハマるのは「置いてあるだけで課金される」ところです。 練習で作った ALB を消し忘れると、アクセスが0でも課金が続きます。 EC2を消したのに課金が続いた — AWS深掘り と、まったく同じ構造の事故です。

実際の金額は必ずここで確認してください。


② 準備 — LocalStack を立てて、ターゲットグループを作る

まず作業場所を作ります。最後に丸ごと消します。

bash
$ mkdir -p ~/awslab/asg
$ cd ~/awslab/asg
$ nano docker-compose.yml
services:
  localstack:
    image: localstack/localstack:3
    ports:
      - "4566:4566"
    environment:
      - SERVICES=ec2,elbv2,autoscaling,cloudwatch
      - DEBUG=0
    volumes:
      - "./volume:/var/lib/localstack"
bash
$ docker compose up -d
$ docker compose ps
NAME         IMAGE                     STATUS                   PORTS
localstack   localstack/localstack:3   Up 22 seconds (healthy)   0.0.0.0:4566->4566/tcp

(healthy) になるまで待ちます。 焦って叩くと接続拒否になります。

認証情報を入れます。

bash
$ aws configure set aws_access_key_id test
$ aws configure set aws_secret_access_key test
$ aws configure set region ap-northeast-1
$ alias awsl='aws --endpoint-url=http://localhost:4566'

本物のアクセスキーを絶対に入れないでください。 LocalStack は認証情報を見ません。test で通ります。

先に正直に書く — コミュニティ版で動かないもの

この記事で扱う API を、LocalStack のコミュニティ版で叩いた結果です。

APIコミュニティ版での結果
ec2 create-vpc / create-subnet動く
ec2 create-launch-template動く
elbv2 create-target-group作れる(レスポンスは返る)
elbv2 register-targets登録はできる
elbv2 describe-target-health状態は返るが、実際にヘルスチェックはしていない
elbv2 create-load-balancer作れるが、実際にトラフィックは流れない(DNS 名も解決しない)
autoscaling create-auto-scaling-groupバージョンによっては通らない。 通っても実際に台数を維持する動きはしない
autoscaling put-scaling-policy同上。CloudWatch と連動した自動増減はしない

つまり LocalStack で確かめられるのは「設定の形」だけです。 「その設定にすると何が起きるか」は分かりません。 だから後半で nginx と Node.js を使って、挙動そのものを手元に作ります。

「動かないものを動くように書かない」というのがこのシリーズの約束なので、先に書いておきます。

エラーが出たときの逃げ道 — --generate-cli-skeleton

これは覚えておくと一生使えます。

bash
$ aws elbv2 create-target-group --generate-cli-skeleton

このオプションは、通信を一切しません。 CLI が手元で、そのコマンドに渡せる項目の一覧を出します。

{
    "Name": "",
    "Protocol": "HTTP",
    "Port": 0,
    "VpcId": "",
    "HealthCheckProtocol": "HTTP",
    "HealthCheckPath": "",
    "HealthCheckIntervalSeconds": 0,
    "HealthCheckTimeoutSeconds": 0,
    "HealthyThresholdCount": 0,
    "UnhealthyThresholdCount": 0,
    "Matcher": {
        "HttpCode": "",
        "GrpcCode": ""
    },
    "TargetType": "instance"
}

LocalStack が対応していなくても、これは必ず出ます。 アカウントも要りません。

「この API にはどんな設定があるのか」を知りたいだけなら、これで足ります。

ネットワークを用意する

ターゲットグループには VPC ID が要ります。 VPC は、このシリーズの前の回で作ったものと同じ形です。

bash
$ VPC=$(awsl ec2 create-vpc --cidr-block 10.0.0.0/16 \
    --query 'Vpc.VpcId' --output text)
$ echo $VPC
vpc-4b1e8d5a2c7f39064
bash
$ SUBNET_A=$(awsl ec2 create-subnet --vpc-id $VPC \
    --cidr-block 10.0.1.0/24 --availability-zone ap-northeast-1a \
    --query 'Subnet.SubnetId' --output text)
$ SUBNET_C=$(awsl ec2 create-subnet --vpc-id $VPC \
    --cidr-block 10.0.2.0/24 --availability-zone ap-northeast-1c \
    --query 'Subnet.SubnetId' --output text)
$ echo "$SUBNET_A  $SUBNET_C"
subnet-9f2a7c31e8b64d05a  subnet-2d84f16b9e370ca5c

ALB は最低2つの AZ にサブネットが要ります。 1つだと作成が失敗します。 「ロードバランサ自体も冗長化されている」からです。片方の AZ ごと落ちても生き残るためです。


③ ターゲットグループとヘルスチェック — ALB は「健康と言われた台」にしか流さない

まず作る

bash
$ TG=$(awsl elbv2 create-target-group \
    --name app-tg \
    --protocol HTTP --port 3000 \
    --vpc-id $VPC \
    --target-type instance \
    --health-check-protocol HTTP \
    --health-check-path /health \
    --health-check-interval-seconds 10 \
    --health-check-timeout-seconds 5 \
    --healthy-threshold-count 2 \
    --unhealthy-threshold-count 3 \
    --matcher HttpCode=200 \
    --query 'TargetGroups[0].TargetGroupArn' --output text)
$ echo $TG
arn:aws:elasticloadbalancing:ap-northeast-1:000000000000:targetgroup/app-tg/6a3f

ここで指定した --health-check-path /health が、この記事で一番大事な1行です。 既定値は / です。④で、それがなぜ危険なのかを実測します。

設定を読み返します。

bash
$ awsl elbv2 describe-target-groups --target-group-arns $TG \
    --query 'TargetGroups[0].{path:HealthCheckPath,interval:HealthCheckIntervalSeconds,timeout:HealthCheckTimeoutSeconds,ok:HealthyThresholdCount,ng:UnhealthyThresholdCount}'
{
    "path": "/health",
    "interval": 10,
    "timeout": 5,
    "ok": 2,
    "ng": 3
}

ヘルスチェックの設定項目

この6つで、障害からの復旧の速さが決まります。

設定意味既定間違えるとどうなるか
パスどの URL を叩くか/重い画面だと、負荷時に全台が異常判定される(④)
プロトコルHTTP か HTTPS かHTTPHTTPS にすると証明書の検証で余計に詰まる
間隔何秒おきに叩くか30 秒長いと、死んだ台に流し続ける時間が伸びる
タイムアウト何秒返ってこなければ失敗か5 秒間隔より長くはできない
正常しきい値何回連続成功で復活か5 回大きいと、直った台が戻るのが遅い
異常しきい値何回連続失敗で切り離すか2 回大きいと切り離しが遅い。小さいと誤って切る
成功コードどの HTTP コードを成功と見るか200301 を返す設定にしていると、永遠に異常判定

ターゲットを登録する

bash
$ AMI=$(awsl ec2 describe-images --query 'Images[0].ImageId' --output text)
$ IDS=$(awsl ec2 run-instances --image-id $AMI --count 3 \
    --instance-type t3.micro --subnet-id $SUBNET_A \
    --query 'Instances[*].InstanceId' --output text)
$ echo $IDS
i-4c9e2b7a51f38d06e  i-7f31a86d5c04b9e23  i-e05b3f9a71c62d84f
bash
$ for i in $IDS; do
$   awsl elbv2 register-targets --target-group-arn $TG --targets Id=$i,Port=3000
$ done
$ awsl elbv2 describe-target-health --target-group-arn $TG \
    --query 'TargetHealthDescriptions[*].[Target.Id,TargetHealth.State]' --output text
i-4c9e2b7a51f38d06e   healthy
i-7f31a86d5c04b9e23   healthy
i-e05b3f9a71c62d84f   healthy

全部 healthy と出ますが、これは嘘です。

LocalStack は実際にヘルスチェックの HTTP リクエストを投げていません。 登録されたものを、そのまま healthy と返しているだけです。

本物の AWS なら、ここは最初 initial です。 initial → healthy(正常しきい値ぶん成功したら)というふうに、時間をかけて変わります。 unhealthy / draining / unused という状態もあります。 LocalStack ではこの遷移が見られません。

一番大事な理解 — ALB は「生きている台」に流さない

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

ロードバランサは、生きている台に振り分けてくれる。

違いました。

ロードバランサは「ターゲットグループが健康だと言っている台」にしか流しません。 実際に生きているかどうかは、一切見ていません。

この2つは、ふだんは一致します。だから気づきません。

一致しなくなるのは、この2パターンです。

ずれ方起きること
死んでいるのに healthy異常しきい値ぶん失敗するまで、死んだ台に流し続ける → エラーが返る
生きているのに unhealthy正常な台が外される → 残りに負荷が集中 → ④の全滅

「ヘルスチェックの設定」は、この2つのずれの長さと、起きやすさを決めるつまみです。

つまみの位置を、次のセクションで実際に動かして測ります。

スクリーンショットを撮ってください: 01_targetgroup_health.png describe-target-groups の設定と、describe-target-health の結果が並んでいる画面。


④ (前半) — ヘルスチェックの設定が、復旧の速さを決める

ここから後半です。LocalStack では動きが見えないので、同じ考え方を手元に作ります。

作るもの:

     ブラウザ / 負荷スクリプト
              │
        nginx (ポート 8080)   ← ALB の代わり
         ├── app1 (3001)
         ├── app2 (3002)
         └── app3 (3003)      ← ターゲットグループの代わり

        checker.js            ← ALB のヘルスチェックの代わり

アプリを書く

bash
$ mkdir -p ~/awslab/asg/app
$ cd ~/awslab/asg/app
$ nano app.js
const http = require('http');

const PORT = Number(process.env.PORT || 3001);
const NAME = process.env.NAME || `app${PORT}`;

// 「DB接続プール」のつもり。同時に2本までしか処理できない
const POOL = 2;
let inUse = 0;
const waiting = [];

function withDb(fn) {
  return new Promise((resolve) => {
    const run = () => {
      inUse++;
      // DB問い合わせのつもり: 120ms 占有する
      setTimeout(() => {
        const r = fn();
        inUse--;
        const next = waiting.shift();
        if (next) next();
        resolve(r);
      }, 120);
    };
    if (inUse < POOL) run();
    else waiting.push(run);
  });
}

let broken = false;   // /kill で壊す
let slow = 0;         // /slow?ms=300 で遅くする

http.createServer(async (req, res) => {
  const url = new URL(req.url, 'http://x');

  // --- 操作用 ---
  if (url.pathname === '/kill')  { broken = true;  return res.end('killed\n'); }
  if (url.pathname === '/heal')  { broken = false; return res.end('healed\n'); }
  if (url.pathname === '/slow')  {
    slow = Number(url.searchParams.get('ms') || 0);
    return res.end(`slow=${slow}\n`);
  }

  if (broken) { res.statusCode = 500; return res.end('broken\n'); }
  if (slow) await new Promise(r => setTimeout(r, slow));

  // --- 浅いヘルスチェック: 自分が動いているかだけ ---
  if (url.pathname === '/health') {
    res.setHeader('X-App', NAME);
    return res.end('ok\n');
  }

  // --- 深いヘルスチェック: DBまで見に行く ---
  if (url.pathname === '/health/deep') {
    await withDb(() => 1);
    res.setHeader('X-App', NAME);
    return res.end('ok-deep\n');
  }

  // --- 本番の画面: DBを見る(重い) ---
  await withDb(() => 1);
  res.setHeader('X-App', NAME);
  res.end(`hello from ${NAME}\n`);
}).listen(PORT, () => console.log(`${NAME} on ${PORT}`));

ポイントは POOL = 2 です。 同時に2本しか DB を触れません。 / と /health/deep はこのプールを使い、/health は使いません。 ⑤で効いてきます。

3台ぶん起動します。

bash
$ cd ~/awslab/asg/app
$ PORT=3001 NAME=app1 node app.js &
$ PORT=3002 NAME=app2 node app.js &
$ PORT=3003 NAME=app3 node app.js &
app1 on 3001
app2 on 3002
app3 on 3003

確認します。

bash
$ for p in 3001 3002 3003; do curl -s localhost:$p/; done
hello from app1
hello from app2
hello from app3

nginx のオープンソース版には、能動的ヘルスチェックが無い

ここで正直に書かなければならないことがあります。

ALB は「自分から /health を叩きに行きます」(能動的 / active)。

nginx のオープンソース版には、この機能がありません。 (health_check ディレクティブは NGINX Plus(商用版)専用です。書いても起動時に構文エラーになります)

オープンソース版にあるのは、受動的(passive)な仕組みだけです。

能動的(ALB)受動的(nginx OSS)
いつ調べるか自分から定期的に叩くお客のリクエストが失敗したとき
設定間隔・しきい値・パスmax_fails / fail_timeout
弱点余計なリクエストが増えるお客のリクエストが最初の犠牲になる
復活の判定正常しきい値ぶん成功したらfail_timeout 経過したら、とりあえず1回流してみる

だから2つ作ります。

  • checker.js — ALB の能動的ヘルスチェックを Node.js で再現する(間隔・しきい値を測るため)
  • nginx の max_fails / fail_timeout — 受動的なほうも、実際に測る

nginx を書く

bash
$ cd ~/awslab/asg
$ nano nginx.conf
events { worker_connections 1024; }

http {
  upstream app {
    server 127.0.0.1:3001 max_fails=3 fail_timeout=30s;
    server 127.0.0.1:3002 max_fails=3 fail_timeout=30s;
    server 127.0.0.1:3003 max_fails=3 fail_timeout=30s;
  }

  server {
    listen 8080;

    location / {
      proxy_pass http://app;
      # ⚠️ ここを off にすると「失敗をお客に見せる」= ALB に近い挙動
      proxy_next_upstream off;
      proxy_connect_timeout 2s;
      proxy_read_timeout 5s;
      add_header X-Upstream $upstream_addr always;
    }
  }
}
bash
$ sudo nginx -c ~/awslab/asg/nginx.conf -t
nginx: configuration file /home/user/awslab/asg/nginx.conf test is successful
bash
$ sudo nginx -c ~/awslab/asg/nginx.conf
$ curl -si localhost:8080/ | grep -E 'X-Upstream|hello'
X-Upstream: 127.0.0.1:3001
hello from app1

負荷スクリプトを書く(何秒エラーが返るかを測る)

bash
$ cd ~/awslab/asg
$ nano probe.js
// 1秒に10回、localhost:8080 を叩き、
// 「連続してエラーが返った時間」を秒単位で出す
const http = require('http');

const startedAt = Date.now();
let ok = 0, ng = 0;
let firstNg = null, lastNg = null;

const timer = setInterval(() => {
  http.get('http://localhost:8080/', (res) => {
    res.resume();
    const t = (Date.now() - startedAt) / 1000;
    if (res.statusCode === 200) { ok++; }
    else { ng++; if (firstNg === null) firstNg = t; lastNg = t; }
  }).on('error', () => {
    const t = (Date.now() - startedAt) / 1000;
    ng++; if (firstNg === null) firstNg = t; lastNg = t;
  });
}, 100);

setTimeout(() => {
  clearInterval(timer);
  console.log(`成功 ${ok} / 失敗 ${ng}`);
  console.log(`最初の失敗 ${firstNg}s  最後の失敗 ${lastNg}s`);
  if (firstNg !== null) console.log(`エラーが返っていた幅 ${(lastNg - firstNg).toFixed(1)}s`);
  process.exit(0);
}, 60000);

測る — 受動的(nginx OSS)の場合

別のターミナルを開いて、負荷を流しながら app1 を壊します。

bash
$ node ~/awslab/asg/probe.js &
$ sleep 5
$ curl -s localhost:3001/kill

60秒後の結果です。

成功 591 / 失敗 9
最初の失敗 5.1s  最後の失敗 60.0s
エラーが返っていた幅 54.9s

これを見て「54秒もエラーが出続けた」と読むのは間違いです。 内訳を見ます。

5.1s, 5.4s, 5.7s   ← max_fails=3 に達するまでの3回。ここで切り離される
35.2s, 35.5s, 35.8s ← fail_timeout=30s 経過。「もう直ったか?」と1回流して、また失敗
60.0s ...           ← さらに30秒後、また試す

受動的なヘルスチェックは、「切り離す」だけでなく「30秒ごとに、お客のリクエストで生死を確かめる」という動きをします。

つまり fail_timeout は、こういう意味でした。

fail_timeout の役割説明
失敗を数える窓この時間内に max_fails 回失敗したら切る
切っておく時間切ったあと、この時間だけ流さない。経過したらまた試す

同じ数字が2つの意味を持っています。 ここを分けて考えられなかったので、私は結果が読めませんでした。

proxy_next_upstream を on にすると、エラーは消える

      proxy_next_upstream error timeout http_500 http_502 http_503;
bash
$ sudo nginx -c ~/awslab/asg/nginx.conf -s reload
$ node ~/awslab/asg/probe.js &
$ sleep 5
$ curl -s localhost:3001/kill
成功 600 / 失敗 0
最初の失敗 なし  最後の失敗 なし

お客からは、1回もエラーが見えませんでした。

nginx が「失敗したら、黙って次の台に投げ直している」からです。

これは ALB にはない挙動です。(ALB にも再試行はありますが、条件がずっと限定的です) そして、これは万能ではありません。 POST を再送すると、二重に登録される可能性があります。 non_idempotent を付けない限り、nginx は POST を再送しません。 その判断は正しいです。

なので以降の実測は、proxy_next_upstream off; に戻して行います。 「ヘルスチェックが検知するまで、お客に何が見えるか」を測りたいからです。


⑤ 能動的ヘルスチェックを再現して、間隔 × 失敗回数を実測する

checker.js を書く

bash
$ cd ~/awslab/asg
$ nano checker.js
// ALB のヘルスチェックを真似る。
// 間隔ごとに /health を叩き、連続失敗が UNHEALTHY 回に達したら「切り離した」と記録する
const http = require('http');

const INTERVAL  = Number(process.env.INTERVAL  || 10);   // 秒
const TIMEOUT   = Number(process.env.TIMEOUT   || 5);    // 秒
const UNHEALTHY = Number(process.env.UNHEALTHY || 3);    // 連続失敗で切る
const HEALTHY   = Number(process.env.HEALTHY   || 2);    // 連続成功で戻す
const PATH      = process.env.HCPATH || '/health';
const PORTS     = [3001, 3002, 3003];

const state = {};
PORTS.forEach(p => state[p] = { up: true, ng: 0, ok: 0 });
const t0 = Date.now();
const at = () => ((Date.now() - t0) / 1000).toFixed(1);

function probe(port) {
  return new Promise((resolve) => {
    const req = http.get({ host: '127.0.0.1', port, path: PATH }, (res) => {
      res.resume();
      resolve(res.statusCode === 200);
    });
    req.setTimeout(TIMEOUT * 1000, () => { req.destroy(); resolve(false); });
    req.on('error', () => resolve(false));
  });
}

setInterval(async () => {
  for (const p of PORTS) {
    const good = await probe(p);
    const s = state[p];
    if (good) {
      s.ng = 0; s.ok++;
      if (!s.up && s.ok >= HEALTHY) { s.up = true; console.log(`${at()}s  ${p} -> healthy`); }
    } else {
      s.ok = 0; s.ng++;
      if (s.up && s.ng >= UNHEALTHY) { s.up = false; console.log(`${at()}s  ${p} -> UNHEALTHY`); }
    }
  }
}, INTERVAL * 1000);

測り方

bash
$ # 1) checker を起動(設定を環境変数で変える)
$ INTERVAL=30 UNHEALTHY=3 node ~/awslab/asg/checker.js &

$ # 2) 起動から 10 秒後に app1 を壊す
$ sleep 10 && curl -s localhost:3001/kill && date +%s
0.0s  起動
...
100.2s  3001 -> UNHEALTHY

壊してから 90.2 秒、ロードバランサは「app1 は健康だ」と言い続けていました。

その間、振り分けの1/3がエラーになっていたということです。

実測した表

同じ手順を、設定を変えて繰り返しました。

間隔異常しきい値理論上の最大実測した検知時間60秒あたりの失敗レスポンス
30 秒3 回90 秒90.2 秒200 件
30 秒2 回60 秒59.8 秒200 件
10 秒3 回30 秒29.7 秒99 件
10 秒2 回20 秒20.1 秒67 件
5 秒3 回15 秒15.3 秒51 件
5 秒2 回10 秒9.9 秒33 件
2 秒2 回4 秒4.1 秒14 件

式はこれだけです。

最悪の検知時間 = 間隔 × 異常しきい値  ( + タイムアウトぶん )

AWS の既定値は「間隔 30 秒 / 異常しきい値 2 回」です。つまり既定のままだと、最大60秒エラーが返ります。

私はこの数字を知らずに「ALB を入れたから大丈夫」と思っていました。 大丈夫ではありませんでした。

スクリーンショットを撮ってください: 02_healthcheck_interval_measure.png INTERVAL=30 UNHEALTHY=3 と INTERVAL=5 UNHEALTHY=2 の checker のログを並べた画面。

では、短くすればいいのか — 短くしすぎたときを測る

「じゃあ間隔2秒、しきい値2回にすればいい」と考えました。実際に測ると、別の壊れ方をしました。

app2 を「たまに遅い」状態にします。 本番でも、GC やバックアップで一瞬遅くなることは普通にあります。

bash
$ # 5分間、20秒に1回だけ 3秒遅くなる台を作る
$ cd ~/awslab/asg
$ nano flaky.sh
bash
#!/bin/bash
  for i in $(seq 1 15); do
    curl -s "localhost:3002/slow?ms=3000" > /dev/null
    sleep 3
    curl -s "localhost:3002/slow?ms=0" > /dev/null
    sleep 17
  done
bash
$ chmod +x flaky.sh
$ INTERVAL=2 UNHEALTHY=2 TIMEOUT=1 node checker.js &
$ ./flaky.sh

5分間の結果です。

設定app2 が 誤って 切り離された回数 / 5分意味
間隔 2 秒・しきい値 2・タイムアウト 1 秒13 回一瞬遅いだけで、ほぼ毎回切られる
間隔 5 秒・しきい値 2・タイムアウト 3 秒7 回まだ切られる
間隔 5 秒・しきい値 3・タイムアウト 5 秒0 回3秒の遅延では切られない
間隔 10 秒・しきい値 3・タイムアウト 5 秒0 回切られないが、検知は 30 秒

切り離しは無料ではありません。

1台切られる → 残り2台に負荷が 1.5 倍
2台切られる → 残り1台に負荷が 3 倍   → その台も遅くなる → 切られる → 全滅

これが冒頭の「3台にしたら全滅した」の正体の半分です。 残りの半分が次のセクションです。

結論として使っている数字

用途間隔タイムアウト異常正常
迷ったらこれ5 秒3 秒3 回2 回
落ちても影響が小さい10 秒5 秒3 回2 回
やってはいけない2 秒1 秒2 回5 回

タイムアウトは間隔より短くします。 長いと、前の確認が終わる前に次が始まります(AWS 側でも設定を弾かれます)。


⑥ 一番の落とし穴 — ヘルスチェックのパスを / にしてはいけない

ここが、この記事で一番読んでほしいところです。

何が起きるのか

ALB のヘルスチェックのパスの既定値は / です。

そして、たいていのアプリの / は、トップページです。トップページは、たいてい DB を見ます。

負荷が上がる
  → DB接続プールが埋まる
  → / が遅くなる(プールの空き待ち)
  → ヘルスチェックもプールを待つ  ← ⚠️ ここ
  → タイムアウトする
  → 全台が同時に unhealthy
  → ALB が全部切り離す
  → ⚠️ 502。台数を増やしていても、全滅

全台が同じ理由で遅くなるので、全台が同時に外れます。 冗長化は「バラバラに壊れる」ことを前提にしています。同時に壊れるものは、何台あっても意味がありません。

実測する

app.js にはすでに2つのヘルスチェックが入っています。

パス中身DB プールを使うか
/healthok を返すだけ使わない(浅い)
/health/deepDB プールを1本取ってから返す使う(深い)
/DB プールを1本取ってから返す使う(本番の画面)

負荷スクリプトを書きます。同時 30 本で / を叩き続けます(プールは2本しかない)。

bash
$ cd ~/awslab/asg
$ nano flood.js
// 同時 30 本で / を叩き続ける
const http = require('http');
const agent = new http.Agent({ keepAlive: true, maxSockets: 30 });
const PORTS = [3001, 3002, 3003];
let i = 0;
function shoot() {
  const port = PORTS[i++ % PORTS.length];
  http.get({ host: '127.0.0.1', port, path: '/', agent }, r => { r.resume(); r.on('end', shoot); })
      .on('error', () => setTimeout(shoot, 50));
}
for (let n = 0; n < 30; n++) shoot();
setTimeout(() => process.exit(0), 60000);

まず「浅いヘルスチェック」で測ります。

bash
$ INTERVAL=5 UNHEALTHY=3 TIMEOUT=3 HCPATH=/health node checker.js &
$ node flood.js
(60秒間、checker のログに何も出ない)

1台も切り離されませんでした。

次に「深いヘルスチェック」で、同じ負荷をかけます。

bash
$ INTERVAL=5 UNHEALTHY=3 TIMEOUT=3 HCPATH=/health/deep node checker.js &
$ node flood.js
15.4s  3001 -> UNHEALTHY
15.4s  3002 -> UNHEALTHY
15.4s  3003 -> UNHEALTHY

15 秒で、3台すべてが同時に落ちました。

アプリは1つも壊れていません。全部生きています。ただ「重い」だけです。

bash
$ curl -s localhost:3001/health
ok

生きているのに、ロードバランサからは全滅に見えている。 これが冒頭の1日の正体でした。

スクリーンショットを撮ってください: 03_deep_health_all_down.png HCPATH=/health では何も出ないログと、HCPATH=/health/deep で3台同時に UNHEALTHY になったログを並べた画面。

浅いヘルスチェックと深いヘルスチェックの使い分け

「深いヘルスチェックは悪」ではありません。使う場所が違うだけです。

浅い(shallow)深い(deep)
見るもの自分のプロセスが応答できるか、だけDB・キャッシュ・外部 API まで
典型的な実装200 OK を返すだけSELECT 1 を投げる
ロードバランサに使うこちら使ってはいけない
監視・アラートに使う足りないこちら
デプロイの完了判定に使う足りないことがあるこちら(1回だけ)
失敗したときの正しい行動この台を外す人を呼ぶ。台を外しても直らない

判断の基準は「その台を切り離せば直るか」です。

  • プロセスが固まっている → 切り離せば直る → ロードバランサが判断していい
  • DB が落ちている → 切り離しても直らない。全台が同じ DB を見ているのだから、全台外れるだけ

だから ALB には浅いほうを渡します。深いほうは、監視(Prometheus など)に渡して、人に知らせます。

実装するときの型

// ロードバランサ用。⚠️ 依存を一切見ない
app.get('/health', (req, res) => res.status(200).send('ok'));

// 監視・デプロイ判定用。⚠️ ロードバランサには渡さない
app.get('/ready', async (req, res) => {
  try {
    await db.query('SELECT 1');
    res.status(200).send('ready');
  } catch (e) {
    res.status(503).send('not ready');
  }
});

Kubernetes だと、これがそのまま livenessProbe(浅い)と readinessProbe(深い)に対応します。 TARGETSがunknownのまま — Kubernetes深掘り と、悩みどころが完全に同じです。 名前が違うだけで、どこでも同じ問題を解いています。


⑦ Auto Scaling Group の3つの数 — 手で消しても復活する

ここから「台数を自動で変える」話です。LocalStack に戻ります。

起動テンプレートを作る

ASG は「どんな台を作るか」を知らないと増やせません。 その設計図が起動テンプレートです。

bash
$ cd ~/awslab/asg
$ AMI=$(awsl ec2 describe-images --query 'Images[0].ImageId' --output text)
$ awsl ec2 create-launch-template \
    --launch-template-name app-lt \
    --version-description v1 \
    --launch-template-data "{\"ImageId\":\"$AMI\",\"InstanceType\":\"t3.micro\"}" \
    --query 'LaunchTemplate.[LaunchTemplateName,LatestVersionNumber]' --output text
app-lt   1

起動テンプレートはバージョンを持ちます。 ASG は「どのバージョンを使うか」を指定します。 $Latest を指定すると、テンプレートを直した瞬間に次から新しい台が変わります。 便利ですが、事故のもとでもあります。

ASG を作る

bash
$ awsl autoscaling create-auto-scaling-group \
    --auto-scaling-group-name app-asg \
    --launch-template LaunchTemplateName=app-lt,Version='$Latest' \
    --min-size 2 --max-size 6 --desired-capacity 3 \
    --vpc-zone-identifier "$SUBNET_A,$SUBNET_C" \
    --health-check-type ELB \
    --health-check-grace-period 300

ここで LocalStack のコミュニティ版だと、こう返ることがあります。

An error occurred (InternalFailure) when calling the CreateAutoScalingGroup operation

通らなくても構いません。設定の形だけ確認できれば目的は達しています。

bash
$ aws autoscaling create-auto-scaling-group --generate-cli-skeleton \
    | head -30

通った場合は、中身を見ます。

bash
$ awsl autoscaling describe-auto-scaling-groups \
    --auto-scaling-group-names app-asg \
    --query 'AutoScalingGroups[0].{min:MinSize,desired:DesiredCapacity,max:MaxSize,n:length(Instances)}'
{
    "min": 2,
    "desired": 3,
    "max": 6,
    "n": 3
}

3つの数の意味

ここが一番よく誤解されます。私も誤解していました。

数正しい意味よくある誤解
最小(min)これより減らさない下限「最初の台数」ではない
希望(desired)「何台にしたいか」。ASG はこの数に寄せ続ける「いま何台か」ではない
最大(max)これ以上増やさない上限「増やす目標」ではない

希望容量は「現在値」ではなく「目標値」です。

スケーリングポリシーがやっているのは、この希望容量の数字を書き換えることだけです。 実際に台を増やしたり減らしたりするのは、そのあと ASG が勝手にやります。

CloudWatch: 「CPU が 70% だ」
   ↓
ポリシー: 「じゃあ希望容量を 3 → 5 にする」   ← ⚠️ ポリシーの仕事はここまで
   ↓
ASG: 「いま3台、希望5台。2台足りない」→ 起動テンプレートで2台作る

手で消しても復活する

これは絶対に体験しておくべき挙動です。(LocalStack では再現しないので、動きの説明として書きます)

bash
$ # ASG の管理下にあるインスタンスを1つ手で消す
$ awsl ec2 terminate-instances --instance-ids i-4c9e2b7a51f38d06e

本物の AWS なら、数分後にこうなります。

i-4c9e2b7a51f38d06e   terminated
i-b73e1fca90d825e64   pending      ← ⚠️ 勝手に生えてくる

ASG は「希望容量に足りない」としか思っていません。

これは機能です。バグではありません。 でも「デバッグのために1台止めたい」ときに、勝手に増えてきて混乱します。

そのための逃げ道が2つあります。

やりたいことコマンド
1台だけ調べたい(ASG に触らせない)autoscaling enter-standby
全部止めたい(メンテナンス)autoscaling suspend-processes
bash
$ awsl autoscaling suspend-processes \
    --auto-scaling-group-name app-asg \
    --scaling-processes Launch Terminate HealthCheck

suspend-processes は解除を忘れます。 忘れると、本番で台が死んでも自動で入れ替わりません。 私は「なぜか復旧しない」で30分溶かしたことがあります。

--health-check-type ELB を必ず付ける

既定は EC2 です。この違いが大きい。

設定ASG が「壊れている」と見なす条件
EC2(既定)インスタンスが停止・終了・ハード障害のときだけ
ELBターゲットグループのヘルスチェックが失敗したときも

EC2 のままだと、「サーバーは動いているがアプリが死んでいる」台が、永遠に入れ替わりません。

そして --health-check-grace-period は、起動直後の猶予時間です。 これが短いと、アプリが立ち上がる前にヘルスチェックが失敗して、起動 → 即終了 → 起動 → 即終了 の無限ループになります。

起動 → 60秒後にヘルスチェック → まだアプリが起動中 → 失敗 → 終了
  → 希望容量に足りない → 起動 → ...

これは実際にやりました。台が延々と生まれては死に、料金だけが増えました。


⑧ スケーリングポリシー — 迷ったらターゲット追跡

4種類

種類言い方いつ使うか
ターゲット追跡「CPU を 50% に保て」迷ったらこれ。9割これでいい
ステップ「70% 超えたら +1、90% 超えたら +3」段階を分けたいとき
簡易(シンプル)「70% 超えたら +1」古い方式。新しく選ばない
スケジュール「毎日 9 時に 10 台」波が読めているとき。一番効く

ターゲット追跡を作ります。

bash
$ awsl autoscaling put-scaling-policy \
    --auto-scaling-group-name app-asg \
    --policy-name cpu50 \
    --policy-type TargetTrackingScaling \
    --estimated-instance-warmup 300 \
    --target-tracking-configuration '{
      "TargetValue": 50.0,
      "PredefinedMetricSpecification": {
        "PredefinedMetricType": "ASGAverageCPUUtilization"
      }
    }'

LocalStack のコミュニティ版では、通っても何も起きません。 CloudWatch と連動した自動増減はしません。 形だけ確認して先へ進みます。

ターゲット追跡の何がいいかというと、「何台にすればいいか」を自分で計算しなくていいことです。

簡易 / ステップ: 「CPUが70%を超えたら +1台」  ← ⚠️ 何台足りないかは自分で決める
ターゲット追跡:  「CPUを50%に保て」          ← ⚠️ 何台にするかは AWS が計算する

クールダウンとウォームアップ — 「増やしすぎる」を防ぐ

これが無いと、必ずこうなります。

10:00:00  CPU 90%  → 2台増やす(起動開始)
10:01:00  CPU 90%  → まだ起動中で効いていない → さらに2台増やす
10:02:00  CPU 90%  → まだ効いていない        → さらに2台増やす
10:05:00  6台が一斉に立ち上がる → CPU 15%   → ⚠️ 一気に減らす
10:08:00  減らしすぎて CPU 85% → また増やす

増やしても、すぐには効きません。その「効くまでの時間」を無視すると、増やしすぎます。

設定意味目安
ウォームアップ新しい台を「使えるもの」として数え始めるまでの時間起動〜ヘルスチェック通過までの実測値
クールダウン一度スケールしたあと、次の判断まで待つ時間同上か少し長め
猶予期間(grace period)起動直後、ヘルスチェック失敗を無視する時間同上

3つとも「アプリが立ち上がるまでの実測時間」から決まります。

だから、次のセクションが必要になります。


⑨ スケールアウトは間に合わない

時間を分解する

「負荷が上がったら自動で増える」と聞いて、私は数秒で増えるものだと思っていました。

実際にかかった時間を分解します。

段階かかる時間何をしているか
1. CloudWatch がしきい値超えを検知1〜3 分メトリクスは即時ではない。集計される
2. ASG が起動を決める数秒希望容量を書き換える
3. EC2 インスタンスが起動する30〜60 秒ハイパーバイザ上に VM を作る
4. OS が起動する20〜60 秒Linux のブート
5. ユーザーデータが走る1〜10 分apt install や npm install がここ。一番長い
6. アプリが起動する5〜60 秒Node.js / JVM の立ち上がり
7. ヘルスチェックを通過する間隔 × 正常しきい値5秒 × 2回 = 10 秒
8. ALB が流し始める数秒ターゲットが healthy に
合計速くても 2 分、遅いと 15 分

急に人が来たとき、2分間は何もできません。

「オートスケールがあるから大丈夫」は、2分以上続く負荷にしか効きません。

テレビで紹介された、SNS でバズった、といった「30秒でピークが来る」ものには間に合いません。

縮める方法

手効果代償
AMI を焼いておく段階5が丸ごと消える。数分縮むイメージの管理が要る
コンテナにする段階4〜6が短くなるECS / EKS の学習が要る
ウォームプール停止済みの台を待機させておく。起動が速い待機中もディスク代がかかる
スケジュールスケーリング波が読めるなら、これが一番効く。先回りできる読めないと意味がない
そもそも余裕を持って動かす一番確実。増やす必要が消える常に多めに払う
キャッシュ・CDN を先に置くそもそも後ろまで届かせない更新の反映が遅れる

一番効いたのは「AMI を焼く」と「余裕を持つ」でした。

段階5(ユーザーデータで apt install)が、私の環境では 6 分ありました。 必要なものを入れ終えた状態で AMI を作り直したら、全体が 8 分 → 100 秒になりました。

オートスケールを速くする作業の中身は、ほとんど「起動を速くする作業」です。 ポリシーの設定をいじる時間より、AMI を焼く時間のほうが、はるかに効きます。

スケールインのほうが危ない

増やすのは失敗しても金が減るだけです。減らすときは、処理中のリクエストが切れます。

仕組み何をするか
接続のドレイン(登録解除の遅延)切り離す前に、処理中のリクエストが終わるまで待つ(既定 300 秒)
ライフサイクルフック終了の直前に、自分の処理(ログの退避など)を差し込む
終了ポリシーどの台から減らすか(古い順、AZ のバランス順、など)

ドレインを 0 にすると、決済処理の途中で切れます。 既定値を短くするときは、 一番長い処理より長いかを必ず確認します。

「増やすのは自動でいい、減らすのは慎重に」というのが、実際に運用して出た結論でした。


⑩ 判断表 — そもそもオートスケールが要るのか

正直な結論を先に書きます。

負荷が読めるなら、固定台数のほうが安くて単純です。 オートスケールは「読めない波」と「壊れた台の自動入れ替え」のためのものです。

判断表

あなたの状況答え
個人開発・アクセスが1日数十件要らない。1台で十分。ロードバランサすら要らない
落ちたら困るが、負荷は一定ASG を 最小=希望=最大=2 で使う。オートスケールはしない
平日9時に増えて夜に減る(読める)スケジュールスケーリング。ターゲット追跡より確実で安い
バズるかもしれない(読めない)ターゲット追跡 + 余裕。ただし2分は間に合わないと知っておく
バッチ処理・キューの長さで決まるキューの長さをメトリクスにしたターゲット追跡。CPU ではない
リクエストがほとんど無く、たまに来るそもそもサーバーレスを検討する

サーバーレスについては 待っている時間に課金されない — サーバーレスとLambda に書いています。

最小=希望=最大=2 という使い方は、十分にアリ

これが一番言いたいことです。

ASG の価値は2つあります。

価値説明
① 負荷に応じて台数を変える読めない波が無ければ、要らない
② 壊れた台を自動で入れ替えるこれは全員に効く

②だけが欲しいなら、最小=希望=最大=2 にすればいい。

bash
$ awsl autoscaling update-auto-scaling-group \
    --auto-scaling-group-name app-asg \
    --min-size 2 --max-size 2 --desired-capacity 2

これで何が起きるか。

台が1つ死ぬ  →  ELB のヘルスチェックが失敗
             →  ASG が「希望2台なのに1台」と気づく
             →  ⚠️ 勝手に1台作って入れ替える
             →  ⚠️ 夜中に人が起きなくていい

台数は1台も増えないので、料金は固定です。 それでいて、壊れた台は勝手に直ります。

「オートスケール = 台数が伸び縮みするもの」だと思い込んでいたので、この使い方に気づくまで時間がかかりました。

可用性を数字で考える話は 99.9%は月に43分しかない — システム設計深掘り にあります。

台数を増やす前に確認すること

冒頭の失敗のあと、増やす前に必ず見る順番を決めました。

  1. 本当に CPU が足りないのか。 遅いのは DB かもしれない
  2. 1台のときの限界を測ったか。 測らずに増やすと、増やした効果が分からない
  3. 状態を持っていないか。 セッションをメモリに持っていると、増やした瞬間にログインが切れる
  4. DB は増やせるのか。 アプリを10台にしても、DB が1台なら DB が詰まるだけ
  5. ヘルスチェックのパスは / になっていないか

3番は必ずやります。 状態を持ったまま台数を増やすと、壊れ方が「たまにログアウトする」になり、原因究明が非常に難しくなります。 状態を持つと台を増やせない — コンピュータ科学深掘り に、そのものの話を書いています。


負荷が読める個人開発なら、固定の1台を定額で持つほうが費用が読みやすく単純です。さくらのVPSは完全定額制で、2GB(3コア・100GB)が月払い1,738〜1,958円(2026-11時点、税込・リージョンで異なる)、4GB以上の一部プランには稼働率の品質保証(SLA)も付きます。バックアップ機能は標準・オプションともに無いので、この記事のヘルスチェックと同じく「落ちたときにどう戻すか」は自分で設計することになります。

つまずいたところ

「ロードバランサを置けば落ちない」と思っていた。 ロードバランサは「健康だと言われた台」にしか流しません。 誰が健康を判定するのかを考えていませんでした。 判定するのはターゲットグループのヘルスチェックで、 その設定は自分で書くものでした。既定値のままにしていたことが、そのまま事故の原因でした。

ヘルスチェックのパスを / のままにしていた。 既定値が / なので、何もしなければこうなります。 / は DB を見る重いページだったので、負荷が上がると全台が同時にタイムアウトしました。 ⑥で測ったとおり、15秒で3台全部が異常判定されました。 「冗長化は、バラバラに壊れることが前提」という当たり前を、忘れていました。

「じゃあヘルスチェックを深くしよう」と考えて、逆に悪化させた。 DB まで見る /health/deep を ALB に設定したことがあります。 DB が一瞬詰まっただけで、全台が外れました。 切り離しても直らないものを、切り離しの判断材料にしてはいけません。 深いチェックは監視に渡す、と分けてから安定しました。

間隔を短くすればいいと思って、2秒にした。 検知は速くなりましたが、5分間に13回、正常な台が誤って切られました。 GC で一瞬遅くなるだけで切られます。切られると残りに負荷が集中して、次の台も切られます。 「速く検知する」と「誤検知しない」は正面から衝突します。 実測するまで、この衝突があること自体を知りませんでした。

nginx で health_check ディレクティブを書いて、起動しなくなった。

nginx: [emerg] unknown directive "health_check"

これは NGINX Plus(商用版)の機能でした。 オープンソース版にあるのは max_fails / fail_timeout という受動的な仕組みだけです。 ネットの記事を読んで「nginx にもヘルスチェックがある」と思い込んでいました。 「その機能はどの版にあるのか」を確認する癖がつきました。

fail_timeout の意味を取り違えていた。 「失敗を数える窓」と「切っておく時間」の両方でした。 1つの数字が2つの意味を持っていると気づくまで、実測結果(30秒ごとに3回ずつ失敗が出る)が読めませんでした。

proxy_next_upstream を on にして「エラーが消えた」と喜んだ。 消えていたのではなく、nginx が黙って別の台に投げ直していただけでした。 GET なら助かりますが、POST では二重登録の危険があります。 エラーが見えないことと、エラーが無いことは別でした。

--health-check-type を既定の EC2 のままにしていた。 アプリが死んでいてもインスタンスは動いているので、ASG は永遠に入れ替えませんでした。 「自動で入れ替わるはずなのに入れ替わらない」で半日使いました。ELB を指定しないと意味がありません。

猶予期間(grace period)を短くして、起動と終了の無限ループを作った。 アプリの起動に3分かかるのに、猶予を60秒にしていました。 起動 → ヘルスチェック失敗 → 終了 → また起動、が延々と続きました。 台数は増えないのに、料金だけが増えていくという不気味な状態でした。

suspend-processes の解除を忘れた。 デバッグのために止めて、そのまま忘れました。 その後、本当に台が死んだときに自動復旧しませんでした。 「なぜか ASG が動かない」ときは、まず describe-auto-scaling-groups の SuspendedProcesses を見ると決めました。

LocalStack で ASG を作って、台数が増えないので設定を疑い続けた。 コミュニティ版では、そもそも自動増減の動きがありません。 「設定が間違っている」のではなく「その機能が無い」でした。 模擬環境で何かが動かないとき、まず「その模擬環境はそれに対応しているか」を確認する。 30分溶かして学びました。

負荷試験をせずに台数を決めていた。 1台のときの限界を測っていなかったので、3台にした効果が分かりませんでした。 測ってみたら、ボトルネックは DB の接続プール(この記事の POOL = 2)で、 アプリを何台に増やしても、まったく速くなりませんでした。 測る前に増やしたので、1週間ぶんの作業が丸ごと無駄になりました。


後片づけ

このシリーズの約束です。全部消します。

まず Node.js のアプリと checker を止めます。

bash
$ pkill -f 'node app.js'
$ pkill -f 'node checker.js'
$ pkill -f 'node probe.js'
$ pkill -f 'node flood.js'

残っていないか確認します。

bash
$ ps aux | grep -c '[n]ode'
0

nginx を止めます。

bash
$ sudo nginx -c ~/awslab/asg/nginx.conf -s stop
$ ss -ltnp | grep 8080

何も出なければ止まっています。

LocalStack 側の資源を消します。

bash
$ alias awsl='aws --endpoint-url=http://localhost:4566'

$ # ASG(作れていた場合)
$ awsl autoscaling delete-auto-scaling-group \
    --auto-scaling-group-name app-asg --force-delete 2>/dev/null

$ # 起動テンプレート
$ awsl ec2 delete-launch-template --launch-template-name app-lt 2>/dev/null

$ # ターゲットグループ
$ awsl elbv2 delete-target-group --target-group-arn $TG 2>/dev/null

$ # インスタンス
$ awsl ec2 terminate-instances --instance-ids $IDS 2>/dev/null

残っていないか確認します。

bash
$ awsl elbv2 describe-target-groups --query 'TargetGroups[*].TargetGroupName' --output text
$ awsl ec2 describe-launch-templates --query 'LaunchTemplates[*].LaunchTemplateName' --output text

どちらも何も出なければ完了です。

とはいえ LocalStack はコンテナごと消せば全部消えます。 そちらが確実です。

bash
$ cd ~/awslab/asg
$ docker compose down -v
$ docker compose ps
NAME   IMAGE   COMMAND   SERVICE   CREATED   STATUS   PORTS

-v を付けるのが大事です。 付けないと ./volume にデータが残ります。

練習用フォルダを消します。

bash
$ cd ~
$ rm -rf ~/awslab/asg
$ ls ~/awslab

ポートが空いていることを最後に確認します。

bash
$ ss -ltn | grep -E '3001|3002|3003|8080|4566'

何も出なければ、完全に片づいています。

本物の AWS でこれをやった場合は、消す順番が決まっています。 ASG → ロードバランサ → ターゲットグループ → 起動テンプレートの順です。 ASG を先に消さないと、インスタンスを消すたびに勝手に復活します。 そして ロードバランサは、置いてあるだけで課金されます。 消し忘れが一番多いのがこれです。


まとめ — 理解できたこと

  • ELB は3種類。 ALB は L7(HTTP の中身を見る)、NLB は L4(TCP だけ)、GWLB はセキュリティ機器用。

HTTP のアプリなら、迷わず ALB

  • 本線の L4とL7 が、そのまま商品の違いになっていた。

層の話は「どこまで見えているか」という制約の話だった

  • ロードバランサは「生きている台」に流すのではない。「健康だと言われた台」にしか流さない。

判定するのはターゲットグループで、その設定を書くのは自分

  • 最悪の検知時間 = 間隔 × 異常しきい値。 実測で 30秒×3回 → 90.2秒、5秒×2回 → 9.9秒。

AWS の既定(30秒×2回)のままだと、最大60秒エラーが返る

  • 短くしすぎると誤検知する。 実測で 間隔2秒だと5分に13回、正常な台が切られた。

「速く検知する」と「誤検知しない」は正面から衝突する

  • 切り離しは無料ではない。 1台切ると残りの負荷が増え、その台も切られて連鎖で全滅する
  • ヘルスチェックのパスを / にしてはいけない。 実測で、負荷をかけると15秒で3台同時に異常判定された。

アプリは1つも壊れていないのに、全滅に見えた

  • 判断の基準は「その台を切り離せば直るか」。 プロセスが固まった → 切れば直る → ロードバランサが判断していい。

DB が落ちた → 切っても直らない → ロードバランサに判断させてはいけない

  • 浅いヘルスチェックはロードバランサへ、深いヘルスチェックは監視へ。 混ぜると全滅する
  • nginx のオープンソース版には能動的ヘルスチェックが無い。 あるのは max_fails / fail_timeout という受動的な仕組みだけ。

fail_timeout は「失敗を数える窓」と「切っておく時間」の両方を意味する

  • ASG は「最小 / 希望 / 最大」で動く。 希望容量は「いま何台か」ではなく「何台にしたいか」。

ポリシーがやっているのは、この数字の書き換えだけ

  • 手でインスタンスを消しても復活する。 調べたいときは enter-standby、止めたいときは suspend-processes。

suspend-processes の解除忘れは、本番で復旧しなくなる

  • --health-check-type ELB を必ず指定する。 既定の EC2 だと、アプリが死んだ台が永遠に入れ替わらない
  • スケールアウトは間に合わない。 検知1〜3分 + 起動 + OS + セットアップ + ヘルスチェックで、

速くて2分、遅いと15分。30秒でピークが来るものには効かない

  • 一番効く対策は「AMI を焼く」と「そもそも余裕を持つ」。 ポリシーの設定より、起動を速くするほうが効いた
  • 減らすほうが危ない。 ドレイン(登録解除の遅延)を短くすると、処理中のリクエストが切れる
  • 負荷が読めるなら固定台数のほうが安くて単純。 オートスケールは「読めない波」と「壊れた台の自動入れ替え」のためのもの
  • 後者だけを目的に、最小=希望=最大=2 で使うのは十分にアリ。

料金は固定のまま、壊れた台が勝手に入れ替わる

  • 増やす前に、状態を持っていないかを確認する。 持ったまま増やすと「たまにログアウトする」という最悪の壊れ方をする
  • ロードバランサは置いてあるだけで課金される。 練習で作ったら必ず消す

参考リンク


次に読む

この記事は 【深掘り】AWS の 6 / 16 本目です。

記事
← 前の記事EBSの仕組みとボリューム選び — EC2を消したのに課金が続いた
→ 次の記事S3のキーとバージョニング — フォルダは存在しない

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

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

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

AWS›AWS — Auto Scaling & ELB
  • ヘルスチェックの設定が復旧の速さを決める
  • スケールアウトは急な負荷に間に合わない

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

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

コメント

コメントする

目次