CloudWatchのメトリクスとアラーム — メモリ使用率は標準では取れない

CloudWatchの監視とアラーム。メトリクスを表示する画面と通知のベル、サーバー。

メモリ使用率は、標準では取れません。CloudWatchのメトリクスとアラームを設定して、必要な値を出せるようにします。

前回: AWSでコンテナを動かす選択肢 — Kubernetesを選ぶ理由がない

これは【深掘り】の記事です。本線の順路ではありません。 監視の考え方そのものは、本線の Prometheusは取りに行く — 監視とログの入口 に書きました。 「なぜ監視するのか」「pull と push の違い」「何を測るべきか」はあちらが本体です。 この記事は CloudWatch という製品固有の話だけを扱います。飛ばしても本線は進めます。

このシリーズは、読者にアカウントを作らせません。 触るのは LocalStack と、aws CLI の --endpoint-url だけです。 課金が発生する操作は一切しません。 料金は具体的な金額を書きません(変わるため)。 何に対して課金されるかという構造だけを書き、数字は公式の料金ページ (CloudWatch の料金)を見てください。 コマンドは VM の中(Ubuntu Server)で打ちます。 最後に docker compose down -v で全部消します。 なお LocalStack は2026年3月23日から1つのイメージに統合され、それ以降の版は起動に auth token(LocalStack のアカウントで取得。無料プランあり)が必要になりました。 この記事では、更新が止まった旧系統の localstack/localstack:3 を固定して使い、アカウントを作らずに進めます。旧イメージの固定は練習用の短期的な手段です(更新が来ず、修正済みの脆弱性が残りうるため)。新しい版を使う場合は、取得した token を LOCALSTACK_AUTH_TOKEN 環境変数に設定します。

最初に正直に書いておきます。 CloudWatch の Metrics と Logs は、LocalStack のコミュニティ版でおおむね動きます。 メトリクスを送って読み返す、ログを送って検索する、アラームを作る、までは実際に手が動きます。 ただし動かないものもあります。 Logs Insights(start-query)とサービスクォータ(service-quotas)は、 コミュニティ版では動かないか、動いても中身が空です。 その部分はそう書いたうえで、 「本物ではどう表示され、どう読むのか」を公式ドキュメントの読み方として示します。 動かないものを「動きます」と書くほうが、あとで読者を困らせるからです。


私は、CPU のグラフだけを見ていました。

練習で立てた小さな Web アプリが、夜中に落ちていました。朝、起きて見に行ったら、 プロセスが死んでいて、docker ps に何もいません。

まず CloudWatch を開きました。 そこにあったのは、こういうグラフです。

CPUUtilization  : 12% → 14% → 11% → 13% ...(ずっと平和)
NetworkIn       : 少し波があるだけ
DiskReadOps     : ほぼ 0

どこにも異常がありませんでした。

CPU は正常です。ネットワークも正常です。なのにサーバーは落ちています。

30分ほど悩んで、VM に入って dmesg を見たときに、答えが出ました。

Out of memory: Killed process 1417 (node) total-vm:2183044kB ...

メモリ不足でした。 Linux のカーネルが、メモリを使いすぎたプロセスを殺していました。 これは OOM Killer と呼ばれる、Linux カーネルの最後の手段です。

ここで私が固まったのは、次の事実です。

CloudWatch のメトリクス一覧に、メモリの項目が1つも無かった。

私は「AWS のサーバーなんだから、AWS が全部測っているはずだ」と思っていました。 思い込みでした。

AWS が標準で見えているのは、「箱の外側」だけです。 箱の中で何が起きているかは、自分で中に人を置かないと分かりません。

この記事は、その「箱の外と中」の線引きから始めます。 そして、見えるようにしたあとで待っている2つ目の壁 — 統計の選び方と、サービスクォータ(上限) まで行きます。


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

目次

この記事でわかること

  • メモリ使用率とディスクの空き容量は、CloudWatch の標準メトリクスに存在しない。「取り忘れ」ではなく構造上そうなっている
  • CloudWatch のメトリクスは「名前」だけでは特定できない。 名前空間・メトリクス名・ディメンションの3点セットで初めて1本の線になる
  • 同じデータでも、平均で見るか最大で見るか p95 で見るかで、結論が正反対になる。 平均だけ見ていると、100人に1人が待たされているのが永久に見えない
  • ログの保持期間の既定は「無期限」。 何も設定しないと、練習で入れたログが消えずに残り続ける
  • アラームの状態は2つではなく3つ。 INSUFFICIENT_DATA(データが来ていない)の扱いを決めないと、一番危ない状態を見逃す
  • AWS のほぼ全部のサービスに上限(クォータ)がある。 そして多くは「当たってから」知る
  • CloudWatch 自体が課金対象。 「全部を細かく取る」は費用として跳ね返る

この記事でやること

  1. 標準で取れるもの / エージェントが要るものを表で切り分け、CloudWatch エージェントの設定ファイルの形を読む
  2. LocalStack を立て、put-metric-data で自作のメトリクスを実際に送り、get-metric-statistics で読み返す
  3. 同じデータに対して Average / Maximum / Sum / p95 を出し、値がまったく違うことを実測する
  4. ロググループとログストリームを作り、保持期間を明示的に設定し、素のテキストログと JSON ログで同じ問いを立てて比べる
  5. put-metric-alarm でアラームを作り、3つの状態と 3 out of 5 の評価、複合アラームを試す
  6. サービスクォータを一覧しようとして、動く範囲と動かない範囲を確かめ、公式ドキュメントの読み方を決める
  7. 請求メトリクスと Budgets の違いを表にして、docker compose down -v で片づける

先に知る言葉

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

言葉意味
メトリクス時刻と数値の組の並び。「10:00 に CPU 12%」を延々と並べたもの
名前空間(Namespace)メトリクスのフォルダのようなもの。AWS 製は AWS/EC2 のように AWS/ で始まる
ディメンション(Dimension)メトリクスに付ける名前と値の組。InstanceId=i-abc のように「どれの数字か」を表す
統計(Statistic)集めた点を1つの値にまとめる方法。平均・最大・合計・パーセンタイルなど
期間(Period)何秒分をまとめて1点にするか。60 なら1分ごとに1点
ロググループ / ログストリームログの入れ物と、その中の1本の流れ。ふつうグループ=アプリ、ストリーム=サーバー1台
保持期間(Retention)ログを何日で自動的に消すか。既定は「消さない」
アラームメトリクスが条件を満たしたときに状態が変わる仕組み。OK / ALARM / INSUFFICIENT_DATA の3つ
サービスクォータAWS が各アカウントに掛けている上限。旧称「サービス制限(Limit)」
CloudWatch エージェントサーバーの中に入れて、メモリやディスクの数字を送るプログラム

① 箱の外側しか、AWS には見えていない

先に結論を置きます。この記事で一番大事なのはここです。

AWS が標準で測っているのは、「仮想サーバーという箱の外側」だけです。 箱の中(メモリ・ディスクの空き・プロセス)は、エージェントを入れないと1つも見えません。

なぜそうなるのかを先に理解すると、丸暗記しなくて済みます。

誰がどこから測っているか

EC2 の CPU 使用率を測っているのは、あなたのサーバーの中のプログラムではありません。 その仮想サーバーを載せている、物理ホスト側(ハイパーバイザー)です。

ハイパーバイザーから見えるのは、こういうものです。

  • この VM に、CPU の時間をどれだけ割り当てたか → CPU 使用率
  • この VM の仮想NICを、何バイト通ったか → ネットワーク量
  • この VM の仮想ディスクに、何回読み書きが飛んだか → ディスクI/O

逆に、外からは絶対に分からないものがあります。

  • メモリの使用率。VM に 4GB 割り当てた、までは外から分かりますが、中で何GB使っているかは、OS の中を見ないと分からない
  • ディスクの空き容量。100GB のボリュームを付けた、は外から分かる。中で何GB埋まっているかは分からない
  • プロセスの一覧、ログ。当然、中の話です

「取り忘れ」ではありません。構造上そうなっています。 そしてこれが、冒頭の「CPU は正常なのに落ちた」の正体です。

表で切り分ける

指標標準で取れるか取れる場合の名前備考
CPU 使用率取れるCPUUtilizationハイパーバイザー側で測っている
ネットワーク受信 / 送信取れるNetworkIn / NetworkOutバイト数
ネットワークパケット数取れるNetworkPacketsIn / Out
ディスクの読み書き回数取れるDiskReadOps / DiskWriteOpsインスタンスストア向け。EBS は別の名前空間
EBS の読み書き取れるAWS/EBS の各種EC2を消したのに課金が続いた — AWS深掘り でやったボリューム側
ステータスチェック取れるStatusCheckFailed「その箱が生きているか」だけ
メモリ使用率取れない(mem_used_percent など任意)エージェントが必要
スワップ使用量取れない(swap_used_percent など)エージェントが必要
ディスクの空き容量取れない(disk_used_percent など)エージェントが必要
プロセス数・特定プロセスの生死取れない(procstat 系)エージェントが必要
アプリのログ取れない—エージェントが必要
アプリ独自の数字(注文数など)取れない任意自分で put-metric-data する

この表の下半分が、全部「自分でやる仕事」です。

AWS の管理コンソールを初めて開いた人が「グラフがたくさんあるから安心だ」と思うのは、 上半分だけを見ているからです。

CloudWatch エージェントの設定ファイルの形

箱の中を見るには、箱の中にプログラムを1つ置きます。 それが CloudWatch エージェントです。

この記事では本物の AWS に繋がないので、エージェントを実際に走らせることはしません。 ただし、設定ファイルの形は読めるようにしておきます。 これが読めないと、 「入れたのに何も出てこない」で止まるからです。

設定ファイルは JSON で、ふつう /opt/aws/amazon-cloudwatch-agent/bin/config.json に置きます。

{
  "agent": {
    "metrics_collection_interval": 60,
    "run_as_user": "cwagent"
  },
  "metrics": {
    "namespace": "MyApp/Host",
    "append_dimensions": {
      "InstanceId": "${aws:InstanceId}"
    },
    "metrics_collected": {
      "mem": {
        "measurement": [
          "mem_used_percent",
          "mem_available"
        ]
      },
      "disk": {
        "resources": ["/"],
        "measurement": [
          "disk_used_percent"
        ],
        "ignore_file_system_types": ["sysfs", "devtmpfs"]
      },
      "swap": {
        "measurement": ["swap_used_percent"]
      }
    }
  },
  "logs": {
    "logs_collected": {
      "files": {
        "collect_list": [
          {
            "file_path": "/var/log/myapp/app.log",
            "log_group_name": "/myapp/app",
            "log_stream_name": "{instance_id}",
            "retention_in_days": 14
          }
        ]
      }
    }
  }
}

読み方の要点は4つです。

  1. metrics_collection_interval が課金に効きます。 60 秒を 10 秒にすると、送る点の数が6倍になります
  2. namespace は自分で決めます。 ここに AWS/EC2 と書くことはできません(AWS 予約)
  3. append_dimensions を書かないと、どのサーバーの数字か分からなくなります。 ②で詳しくやります
  4. retention_in_days をログ側に書いておくと、④で説明する「無期限問題」を最初から避けられます

そして、いちばん忘れられがちなのがこれです。

エージェントには IAM ロールが要ります。 cloudwatch:PutMetricData と logs:CreateLogStream / logs:PutLogEvents の許可が無いと、エージェントは黙って何も送りません。 「入れたのにグラフが出ない」の8割はこれです。 権限の絞り方は AccessDeniedに全権限で答えない — AWS深掘り でやりました。


② メトリクスの構造 — 名前だけでは特定できない

ここから手を動かします。

準備 — LocalStack を立てる

bash
$ mkdir -p ~/awslab/cw
$ cd ~/awslab/cw
$ nano docker-compose.yml
services:
  localstack:
    image: localstack/localstack:3
    ports:
      - "4566:4566"
    environment:
      - SERVICES=cloudwatch,logs,sns
      - DEBUG=0
    volumes:
      - "./volume:/var/lib/localstack"
bash
$ docker compose up -d
$ docker compose ps
NAME         IMAGE                     STATUS                    PORTS
localstack   localstack/localstack:3   Up 18 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 で通ります。 この記事は最初から最後まで、本物の AWS には1度も繋ぎません。

awsl は alias なので、この端末を閉じると消えます。 開き直したら貼り直してください。

メトリクスは4つの部品でできている

1本のグラフの線を特定するのに必要なものは、4つです。

部品例役割
名前空間MyApp/Webどのアプリ・どのサービスの数字か
メトリクス名RequestLatency何を測った数字か
ディメンションService=api, Env=prodそのうちの、どれの数字か
単位Milliseconds何の単位か

そこに「いつの値か」が付いて、初めて1点になります。

実際に1点送ってみる

bash
$ awsl cloudwatch put-metric-data \
    --namespace "MyApp/Web" \
    --metric-name RequestLatency \
    --unit Milliseconds \
    --dimensions Service=api,Env=prod \
    --value 120

何も出力されません。 AWS CLI は、成功したとき黙ることが多いです。 「反応が無い=失敗」ではありません。

送ったものが本当に登録されたかを見ます。

bash
$ awsl cloudwatch list-metrics --namespace "MyApp/Web"
{
    "Metrics": [
        {
            "Namespace": "MyApp/Web",
            "MetricName": "RequestLatency",
            "Dimensions": [
                { "Name": "Service", "Value": "api" },
                { "Name": "Env", "Value": "prod" }
            ]
        }
    ]
}

入っています。

ディメンションが違えば、別のメトリクスになる

ここが、私が最初に踏んだ落とし穴です。

同じ名前空間、同じメトリクス名で、ディメンションだけ変えて送ってみます。

bash
$ awsl cloudwatch put-metric-data \
    --namespace "MyApp/Web" \
    --metric-name RequestLatency \
    --unit Milliseconds \
    --dimensions Service=api,Env=staging \
    --value 900
bash
$ awsl cloudwatch put-metric-data \
    --namespace "MyApp/Web" \
    --metric-name RequestLatency \
    --unit Milliseconds \
    --dimensions Service=batch,Env=prod \
    --value 5000

もう一度、一覧します。

bash
$ awsl cloudwatch list-metrics --namespace "MyApp/Web" \
    --query 'Metrics[*].Dimensions' --output json
[
    [
        { "Name": "Service", "Value": "api" },
        { "Name": "Env", "Value": "prod" }
    ],
    [
        { "Name": "Service", "Value": "api" },
        { "Name": "Env", "Value": "staging" }
    ],
    [
        { "Name": "Service", "Value": "batch" },
        { "Name": "Env", "Value": "prod" }
    ]
]

RequestLatency という名前は1つなのに、メトリクスは3本になりました。

CloudWatch にとって、メトリクスの正体は「名前空間 + 名前 + ディメンションの組み合わせ」です。 ディメンションが1文字でも違えば、それは別の線です。

これが分かっていないと、次の2つで必ず詰まります。

  • get-metric-statistics でディメンションを指定し忘れると、何も返ってこない。

「送ったのに読めない」の原因はほぼこれです

  • ディメンションに「毎回変わる値」を入れると、メトリクスが無限に増える。

リクエストIDやユーザーIDをディメンションに入れると、カスタムメトリクスの数がそのまま費用になります(⑦で扱います)

読み返す — get-metric-statistics

さっき送った点を読み返します。 時刻の指定が要ります。

bash
$ START=$(date -u -d '15 minutes ago' +%Y-%m-%dT%H:%M:%SZ)
$ END=$(date -u -d '5 minutes' +%Y-%m-%dT%H:%M:%SZ)
$ echo "$START -> $END"
2026-10-07T02:41:12Z -> 2026-10-07T03:01:12Z
bash
$ awsl cloudwatch get-metric-statistics \
    --namespace "MyApp/Web" \
    --metric-name RequestLatency \
    --dimensions Name=Service,Value=api Name=Env,Value=prod \
    --start-time "$START" --end-time "$END" \
    --period 300 \
    --statistics Average
{
    "Label": "RequestLatency",
    "Datapoints": [
        {
            "Timestamp": "2026-10-07T02:50:00Z",
            "Average": 120.0,
            "Unit": "Milliseconds"
        }
    ]
}

ここで --dimensions の書き方が put-metric-data と違うことに注意してください。

  • put-metric-data → --dimensions Service=api,Env=prod
  • get-metric-statistics → --dimensions Name=Service,Value=api Name=Env,Value=prod

同じ CLI の中で書式が違います。 私はここで20分溶かしました。

わざと間違えてみます。 ディメンションを省いて読んでみましょう。

bash
$ awsl cloudwatch get-metric-statistics \
    --namespace "MyApp/Web" \
    --metric-name RequestLatency \
    --start-time "$START" --end-time "$END" \
    --period 300 --statistics Average
{
    "Label": "RequestLatency",
    "Datapoints": []
}

空です。エラーにはなりません。

「エラーが出ないのに何も返ってこない」は、CloudWatch で最もよく出る症状です。 原因の候補は3つで、上から順に疑います。

  1. ディメンションが一致していない(今回のこれ)
  2. 時刻の範囲がずれている(--start-time が未来、--end-time が過去)
  3. --period が粗すぎる / 細かすぎる

スクリーンショットを撮ってください: 01_metric_dimensions.png list-metrics の出力で、同じ名前のメトリクスが3本に分かれているところが写るようにしてください。 端末の文字が読める大きさで。


③ 統計の選び方で、結論が変わる

ここも山場です。

②では1点しか送っていません。「平均」も「最大」も同じ値になります。 まとまったデータを入れて、統計を切り替えてみます。

現実に近いデータを作る

Web アプリの応答時間を想像します。 ほとんどのリクエストは速く、たまに極端に遅いものが混じる。 これが現実の形です。

bash
$ cd ~/awslab/cw
$ nano send-latency.sh
bash
#!/bin/bash
  set -eu
  AWSL="aws --endpoint-url=http://localhost:4566"

  # 95件は 50〜150ms、5件は 3000〜5000ms
  for i in $(seq 1 95); do
    V=$((50 + RANDOM % 100))
    $AWSL cloudwatch put-metric-data \
      --namespace "MyApp/Web" \
      --metric-name PageLatency \
      --unit Milliseconds \
      --dimensions Service=web \
      --value "$V"
  done

  for i in $(seq 1 5); do
    V=$((3000 + RANDOM % 2000))
    $AWSL cloudwatch put-metric-data \
      --namespace "MyApp/Web" \
      --metric-name PageLatency \
      --unit Milliseconds \
      --dimensions Service=web \
      --value "$V"
  done

  echo "sent 100 datapoints"
bash
$ chmod +x send-latency.sh
$ ./send-latency.sh
sent 100 datapoints

100回 API を呼ぶので、少し時間がかかります。 本物の AWS で同じことをすると、これは100回分の PutMetricData 呼び出しとして課金されます。 (本番では複数の値をまとめて送るか、後述の統計セットを使います)

同じデータを、4つの統計で読む

bash
$ START=$(date -u -d '15 minutes ago' +%Y-%m-%dT%H:%M:%SZ)
$ END=$(date -u -d '5 minutes' +%Y-%m-%dT%H:%M:%SZ)

$ awsl cloudwatch get-metric-statistics \
    --namespace "MyApp/Web" --metric-name PageLatency \
    --dimensions Name=Service,Value=web \
    --start-time "$START" --end-time "$END" --period 3600 \
    --statistics Average Maximum Minimum Sum SampleCount
{
    "Label": "PageLatency",
    "Datapoints": [
        {
            "Timestamp": "2026-10-07T02:00:00Z",
            "SampleCount": 100.0,
            "Average": 288.4,
            "Sum": 28840.0,
            "Minimum": 50.0,
            "Maximum": 4886.0,
            "Unit": "Milliseconds"
        }
    ]
}

パーセンタイルは別のオプションで取ります。

bash
$ awsl cloudwatch get-metric-statistics \
    --namespace "MyApp/Web" --metric-name PageLatency \
    --dimensions Name=Service,Value=web \
    --start-time "$START" --end-time "$END" --period 3600 \
    --extended-statistics p50 p90 p95 p99
{
    "Label": "PageLatency",
    "Datapoints": [
        {
            "Timestamp": "2026-10-07T02:00:00Z",
            "ExtendedStatistics": {
                "p50": 99.0,
                "p90": 141.0,
                "p95": 2140.0,
                "p99": 4501.0
            },
            "Unit": "Milliseconds"
        }
    ]
}

数字は毎回変わります。 RANDOM を使っているので、同じにはなりません。 大事なのは、値そのものではなく「桁が違う」ことです。

ここで何が起きているか

同じ100件のデータです。 それを1枚の表にします。

統計値(例)この数字が答えている問い
Average(平均)288ms「ならすと、だいたいどれくらい?」
p50(中央値)99ms「ふつうの人は、どれくらい待つ?」
p952140ms「20人に1人は、どれくらい待つ?」
p994501ms「100人に1人は、どれくらい待つ?」
Maximum4886ms「一番運が悪い人は?」
Sum28840「全部足すといくつ?」(回数系で使う)
SampleCount100「何件あった?」

「応答時間 288ms です」と報告したら、嘘ではありません。 でも、20人に1人が2秒以上待っていることは、その数字からは一生見えません。

平均は、外れ値を薄める道具です。 障害を見つけたいときに、外れ値を薄めてはいけません。

これは 台数を増やしたら遅くなった — システム設計深掘り で扱った「レイテンシは分布で見る」の、CloudWatch 側の実装です。 あちらが考え方、こちらが操作です。

どの指標に、どの統計を使うか

測るもの使う統計理由
応答時間・レイテンシp95 / p99平均だと遅い人が消える
エラー件数Sum平均を取っても意味が無い。「何件あったか」が知りたい
リクエスト数Sum同上
CPU 使用率Average と Maximum の両方平均で傾向、最大で瞬間的な張り付き
メモリ使用率Maximum平均は無意味。一度でも上限に触れたら死ぬから
ディスク使用率Maximum同上。増えたら減らない
キューの滞留数Maximum溜まった瞬間が問題
稼働台数Minimum「一番少ないとき何台か」が可用性

メモリとディスクを Average で見るのは、いちばんやってはいけない組み合わせです。 1時間平均が 60% でも、その中の1分だけ 100% になれば、プロセスは殺されます。 冒頭の私の障害は、仮にメモリを取っていたとしても、平均で見ていたら見逃していました。

統計セット — 100回送らずに済ませる

③の最初で100回 API を叩きましたが、本番でこれをやると回数がそのまま費用になります。 すでに手元で集計できている場合は、統計だけを1回で送れます。

bash
$ awsl cloudwatch put-metric-data \
    --namespace "MyApp/Web" \
    --metric-name PageLatencyBatch \
    --unit Milliseconds \
    --dimensions Service=web \
    --statistic-values SampleCount=100,Sum=28840,Minimum=50,Maximum=4886
bash
$ awsl cloudwatch get-metric-statistics \
    --namespace "MyApp/Web" --metric-name PageLatencyBatch \
    --dimensions Name=Service,Value=web \
    --start-time "$START" --end-time "$END" --period 3600 \
    --statistics Average Maximum SampleCount
{
    "Label": "PageLatencyBatch",
    "Datapoints": [
        {
            "Timestamp": "2026-10-07T02:00:00Z",
            "SampleCount": 100.0,
            "Average": 288.4,
            "Maximum": 4886.0,
            "Unit": "Milliseconds"
        }
    ]
}

平均も最大も、1回の呼び出しで同じ値が出ました。 ただし代償があります。

統計セットで送ると、パーセンタイルは出せません。 元の1件1件が無いので、「95番目の値」を後から計算しようがないからです。

回数を減らすか、p95 を見られるようにするか。 どちらかしか選べません。


④ ログ — 既定は「永久に残る」

メトリクスは数字です。ログは文章です。 CloudWatch では別のサービスとして扱われます。

ロググループとログストリームを作る

bash
$ awsl logs create-log-group --log-group-name /myapp/app
$ awsl logs describe-log-groups --query 'logGroups[*].[logGroupName,retentionInDays]' --output table
------------------------------
|      DescribeLogGroups     |
+---------------+------------+
|  /myapp/app   |  None      |
+---------------+------------+

retentionInDays が None です。これが「無期限」です。

CloudWatch Logs の保持期間の既定は「消さない」です。 明示的に設定しない限り、入れたログは何年でも残り、保管料が発生し続けます。

EC2 を消しても、EBS が残って課金が続くという話を EC2を消したのに課金が続いた — AWS深掘り でやりました。 ログはそれと同じ形の罠です。 サーバーを消してもロググループは残ります。

最初に保持期間を設定する

bash
$ awsl logs put-retention-policy --log-group-name /myapp/app --retention-in-days 14
$ awsl logs describe-log-groups --query 'logGroups[*].[logGroupName,retentionInDays]' --output table
------------------------------
|      DescribeLogGroups     |
+---------------+------------+
|  /myapp/app   |  14        |
+---------------+------------+

設定できる日数は決まった値からしか選べません。(1, 3, 5, 7, 14, 30, 60, 90 … のような離散値) 「10日」は指定できません。

個人の学習用なら、私はこう決めています。

用途保持期間の目安理由
練習・検証1〜7日見返すのは当日か翌日まで
個人アプリの本番14〜30日「先月おかしかった」に耐えられる下限
監査・法令で要るもの長期ただし CloudWatch に置き続けるのは高い。S3 に流す

長期保存を CloudWatch Logs でやるのは、いちばん高い選択肢です。 長く持つなら S3にフォルダは存在しない — AWS深掘り でやった ストレージクラスのほうへ移します。

ログを実際に入れる

bash
$ awsl logs create-log-stream --log-group-name /myapp/app --log-stream-name server-01

ログを入れるにはミリ秒のタイムスタンプが要ります。

bash
$ NOW=$(date +%s000)
$ awsl logs put-log-events \
    --log-group-name /myapp/app \
    --log-stream-name server-01 \
    --log-events \
      timestamp=$NOW,message="GET /items 200 45ms user=alice" \
      timestamp=$((NOW+1000)),message="GET /items/9 404 12ms user=bob" \
      timestamp=$((NOW+2000)),message="POST /orders 500 2100ms user=alice" \
      timestamp=$((NOW+3000)),message="GET /health 200 3ms user=-" \
      timestamp=$((NOW+4000)),message="POST /orders 500 1900ms user=carol"
{
    "nextSequenceToken": "49039859156783..."
}

入ったか確認します。

bash
$ awsl logs filter-log-events --log-group-name /myapp/app \
    --query 'events[*].message' --output text
GET /items 200 45ms user=alice
GET /items/9 404 12ms user=bob
POST /orders 500 2100ms user=alice
GET /health 200 3ms user=-
POST /orders 500 1900ms user=carol

単純な絞り込みならフィルタパターンで書けます。

bash
$ awsl logs filter-log-events --log-group-name /myapp/app \
    --filter-pattern "500" --query 'events[*].message' --output text
POST /orders 500 2100ms user=alice
POST /orders 500 1900ms user=carol

ここで壁に当たる — 素のテキストログの限界

では、こういう問いに答えてください。

「500 が出たリクエストの、応答時間の平均は?」

さっきの出力を見れば、人間なら 2000ms だと分かります。 でも、機械には分かりません。 2100ms はただの文字列で、数字として扱われていないからです。

やろうとすると、こうなります。

bash
$ awsl logs filter-log-events --log-group-name /myapp/app \
    --filter-pattern "500" --query 'events[*].message' --output text \
    | grep -o '[0-9]*ms' | tr -d 'ms' \
    | awk '{s+=$1; n++} END {print s/n}'
2000

出ました。でも、これは AWS がやってくれた仕事ではありません。 私が grep と awk で無理やり切り出しただけです。 ログの書式が1文字変われば、この処理は黙って壊れます。

構造化ログ(JSON)にする

同じ内容を、JSON で入れ直します。

bash
$ awsl logs create-log-group --log-group-name /myapp/json
$ awsl logs put-retention-policy --log-group-name /myapp/json --retention-in-days 7
$ awsl logs create-log-stream --log-group-name /myapp/json --log-stream-name server-01
bash
$ NOW=$(date +%s000)
$ awsl logs put-log-events \
    --log-group-name /myapp/json \
    --log-stream-name server-01 \
    --log-events \
      timestamp=$NOW,message='{"level":"info","method":"GET","path":"/items","status":200,"duration_ms":45,"user":"alice","request_id":"r-001"}' \
      timestamp=$((NOW+1000)),message='{"level":"warn","method":"GET","path":"/items/9","status":404,"duration_ms":12,"user":"bob","request_id":"r-002"}' \
      timestamp=$((NOW+2000)),message='{"level":"error","method":"POST","path":"/orders","status":500,"duration_ms":2100,"user":"alice","request_id":"r-003"}' \
      timestamp=$((NOW+3000)),message='{"level":"info","method":"GET","path":"/health","status":200,"duration_ms":3,"user":"-","request_id":"r-004"}' \
      timestamp=$((NOW+4000)),message='{"level":"error","method":"POST","path":"/orders","status":500,"duration_ms":1900,"user":"carol","request_id":"r-005"}'

JSON にすると、フィルタパターンでも「フィールド」として扱えます。

bash
$ awsl logs filter-log-events --log-group-name /myapp/json \
    --filter-pattern '{ $.status = 500 }' \
    --query 'events[*].message' --output text

LocalStack のコミュニティ版では、この JSON フィルタパターンが効かず、 全件返ってくるか、逆に0件になることがあります。 本物の AWS では、この書き方で絞り込めます。 動かなかったら、--filter-pattern を外して全件取り、jq で確かめてください。

bash
$ awsl logs filter-log-events --log-group-name /myapp/json \
    --query 'events[*].message' --output text \
    | jq -s 'map(select(.status == 500)) | {count: length, avg_ms: (map(.duration_ms) | add / length)}'
{
  "count": 2,
  "avg_ms": 2000
}

grep -o '[0-9]*ms' のような曲芸が要らなくなりました。 status は数字で、duration_ms も数字です。 書式が変わっても、フィールド名が同じなら壊れません。

構造化ログにするかどうかは、「後で何を聞けるか」を決める分岐点です。 素のテキストで出したログは、後から構造化できません。(正規表現で救うしかない) 最初の1行目から JSON で出してください。

この話は、ツールが Loki でも Elasticsearch でも同じです。 ログが3箇所に散っている — Lokiで1画面にする で やった「集める」の次に来るのが、この「聞ける形にする」です。

Logs Insights のクエリ

CloudWatch には、ログに対して SQL のような問い合わせを投げる仕組みがあります。 それが Logs Insights です。

正直に書きます。LocalStack のコミュニティ版では、Logs Insights は動きません。 start-query を投げてみます。

bash
$ awsl logs start-query \
    --log-group-name /myapp/json \
    --start-time $(date -d '1 hour ago' +%s) \
    --end-time $(date +%s) \
    --query-string 'fields @timestamp, @message | limit 5'
An error occurred (InvalidParameterException) when calling the StartQuery operation: ...

あるいは、クエリIDは返るのに get-query-results の中身が空、という形で終わります。 環境によって出方が変わるので、上のエラーの文面そのものは気にしないでください。

動かないものを動くように見せかけても意味が無いので、 ここは「本物の AWS で、マネジメントコンソールの Logs Insights 画面に貼る文字列」として書きます。

クエリ1 — エラーを数える

fields @timestamp, @message
| filter status >= 500
| stats count() as errors by bin(5m)
| sort @timestamp desc

読み方: filter で 500 以上に絞り、bin(5m) で5分ごとの箱に入れて、その中の件数を数える。 bin() が、CloudWatch のグラフの「期間」に相当します。

クエリ2 — 遅い順に並べる

fields @timestamp, path, duration_ms, user, request_id
| filter duration_ms > 1000
| sort duration_ms desc
| limit 20

読み方: どのパスが遅いのかを、実物のリクエストとして見る。 duration_ms を数字として扱えるのは、この節の前半で JSON にしたからです。 素のテキストログだと sort duration_ms desc は書けません。

クエリ3 — 特定のIDを追う

fields @timestamp, @logStream, level, method, path, status, duration_ms
| filter request_id = "r-003"
| sort @timestamp asc

読み方: 1つのリクエストが、どのサーバーで、どういう順に何をしたかを時系列で並べる。 これが request_id を全部のログ行に入れておく理由です。 入れていないと、複数台構成になった瞬間に追跡が不可能になります。

この「1本のリクエストを最後まで追う」を、サービスをまたいで本気でやるのが分散トレーシングです。 1台のうちは request_id で足ります。

集計の例も1つ挙げておきます。

fields @timestamp, path, duration_ms
| stats count() as n, avg(duration_ms) as avg_ms, pct(duration_ms, 95) as p95 by path
| sort p95 desc

③でやった「平均だけ見ない」を、ログ側でもやっています。 avg_ms と p95 を並べて出すのが要点です。

スクリーンショットを撮ってください: 02_json_vs_text_log.png 素のテキストログを grep と awk で無理やり集計した出力と、 JSON ログを jq で集計した出力が、1画面に並んで写るようにしてください。


⑤ アラーム — 状態は2つではなく3つ

グラフを人が見張るのは不可能です。 条件を決めて、機械に見張らせます。

アラームを1つ作る

bash
$ awsl cloudwatch put-metric-alarm \
    --alarm-name latency-high \
    --alarm-description "PageLatency が高い" \
    --namespace "MyApp/Web" \
    --metric-name PageLatency \
    --dimensions Name=Service,Value=web \
    --statistic Average \
    --period 60 \
    --threshold 500 \
    --comparison-operator GreaterThanThreshold \
    --evaluation-periods 1
bash
$ awsl cloudwatch describe-alarms \
    --query 'MetricAlarms[*].[AlarmName,StateValue]' --output table
----------------------------------------
|            DescribeAlarms            |
+-----------------+--------------------+
|  latency-high   | INSUFFICIENT_DATA  |
+-----------------+--------------------+

作った直後は ALARM でも OK でもなく、INSUFFICIENT_DATA です。

3つの状態の意味

状態意味現場での読み方
OKしきい値の内側正常
ALARMしきい値を超えた異常
INSUFFICIENT_DATA判断するためのデータが足りない正常でも異常でもない。「分からない」

私が最初に誤解していたのはここです。

INSUFFICIENT_DATA を「まだ何も起きていない=OK」だと思っていました。 逆です。 メトリクスが1つも来ていないということは、 「サーバーが死んで、エージェントごと止まっている」可能性があります。

「CPU が 90% を超えたら鳴る」アラームは、サーバーが完全に死んだときには鳴りません。 死んだサーバーは CPU の値を送ってこないからです。

これを、--treat-missing-data で明示的に決めます。

bash
$ awsl cloudwatch put-metric-alarm \
    --alarm-name latency-high \
    --namespace "MyApp/Web" \
    --metric-name PageLatency \
    --dimensions Name=Service,Value=web \
    --statistic Average --period 60 \
    --threshold 500 --comparison-operator GreaterThanThreshold \
    --evaluation-periods 1 \
    --treat-missing-data breaching
--treat-missing-data欠けたデータをどう扱うか使いどころ
missing(既定)無かったことにする元々スカスカなメトリクス
notBreaching正常とみなすこれを既定で選ぶと、死んだことに気づけない
breaching異常とみなす「来ていない=おかしい」ものに使う。ヘルスチェック系
ignore直前の状態を維持する一時的な欠測が多いとき

「データが来ない」ことに何の意味を与えるかは、メトリクスごとに違います。 決めていないと、既定の missing が黙って選ばれます。

状態を動かしてみる

LocalStack のコミュニティ版には、アラームを定期的に評価するエンジンがありません。 メトリクスを送っても、放っておくだけでは状態は変わりません。 そこで、状態を手で動かす API を使います。(本物の AWS でも、テスト用にこの API があります)

bash
$ awsl cloudwatch set-alarm-state \
    --alarm-name latency-high \
    --state-value ALARM \
    --state-reason "manual test: notification path check"
bash
$ awsl cloudwatch describe-alarms \
    --alarm-names latency-high \
    --query 'MetricAlarms[*].[AlarmName,StateValue]' --output table
------------------------------
|      DescribeAlarms        |
+----------------+-----------+
|  latency-high  |  ALARM    |
+----------------+-----------+

履歴も残ります。

bash
$ awsl cloudwatch describe-alarm-history \
    --alarm-name latency-high \
    --query 'AlarmHistoryItems[*].[HistorySummary]' --output text
Alarm updated from INSUFFICIENT_DATA to ALARM

set-alarm-state は、本物の AWS でも「通知が本当に届くか」の確認に使えます。 アラームを作っただけで安心してはいけません。 私は、通知先のメールアドレスを打ち間違えたまま3週間気づかなかったことがあります。

戻します。

bash
$ awsl cloudwatch set-alarm-state \
    --alarm-name latency-high --state-value OK --state-reason "test done"

一瞬のスパイクで鳴らさない — M out of N

1分だけ CPU が 90% になっただけで夜中に電話が鳴ったら、 3日でアラームを切ります。 それが一番危険な状態です。

「5回のうち3回悪かったら鳴る」という形にします。

bash
$ awsl cloudwatch put-metric-alarm \
    --alarm-name latency-sustained \
    --namespace "MyApp/Web" \
    --metric-name PageLatency \
    --dimensions Name=Service,Value=web \
    --statistic Average --period 60 \
    --threshold 500 --comparison-operator GreaterThanThreshold \
    --evaluation-periods 5 \
    --datapoints-to-alarm 3 \
    --treat-missing-data missing
bash
$ awsl cloudwatch describe-alarms --alarm-names latency-sustained \
    --query 'MetricAlarms[*].[AlarmName,EvaluationPeriods,DatapointsToAlarm,Period]' --output table
--------------------------------------------------------
|                   DescribeAlarms                     |
+---------------------+------+------+------------------+
|  latency-sustained  |  5   |  3   |  60              |
+---------------------+------+------+------------------+

読み方: 直近5分(60秒 × 5期間)を見て、そのうち3分が超えていたら ALARM。

設定鳴りやすさ向いているもの
1 out of 1極端に鳴る「1回でも起きたら困る」もの(決済の失敗など)
2 out of 2短い持続を見るディスク使用率、メモリ
3 out of 5バランスが良いレイテンシ、エラー率
5 out of 5鈍い明らかに長引いた障害だけ

evaluation-periods を伸ばすほど、気づくのが遅くなります。 「うるさくない」と「早く気づく」はトレードオフです。 無料で両立はできません。

複合アラーム — 2つ同時に悪いときだけ鳴らす

「レイテンシが高い」だけなら、バッチが走っているだけかもしれません。 「レイテンシが高い、かつ、エラーが出ている」なら、それは障害です。

まず2本目のアラームを作ります。

bash
$ awsl cloudwatch put-metric-alarm \
    --alarm-name error-rate-high \
    --namespace "MyApp/Web" \
    --metric-name ErrorCount \
    --dimensions Name=Service,Value=web \
    --statistic Sum --period 60 \
    --threshold 5 --comparison-operator GreaterThanOrEqualToThreshold \
    --evaluation-periods 1 \
    --treat-missing-data notBreaching

2つを AND で束ねます。

bash
$ awsl cloudwatch put-composite-alarm \
    --alarm-name service-degraded \
    --alarm-description "slow AND erroring" \
    --alarm-rule "ALARM(latency-sustained) AND ALARM(error-rate-high)"
bash
$ awsl cloudwatch describe-alarms --alarm-types CompositeAlarm \
    --query 'CompositeAlarms[*].[AlarmName,StateValue]' --output table
--------------------------------------------
|              DescribeAlarms              |
+---------------------+--------------------+
|  service-degraded   | INSUFFICIENT_DATA  |
+---------------------+--------------------+

LocalStack のコミュニティ版では、複合アラームの作成はできても、 子アラームの状態変化に応じて自動で状態が変わることは期待できません。 ここでの目的は、ルールの書き方を覚えることです。

ルールの書き方の例:

ルール意味
ALARM(a) AND ALARM(b)両方悪いときだけ鳴る
ALARM(a) OR ALARM(b)どちらか悪ければ鳴る
ALARM(a) AND NOT ALARM(maintenance)メンテ中フラグが立っていないときだけ鳴る

3つ目が、実運用でいちばん効きます。 「デプロイ中は鳴らさない」を、アラームを消さずに実現できます。

動作テストは、子を手で動かして確かめます。

bash
$ awsl cloudwatch set-alarm-state --alarm-name latency-sustained \
    --state-value ALARM --state-reason "composite test"
$ awsl cloudwatch set-alarm-state --alarm-name error-rate-high \
    --state-value ALARM --state-reason "composite test"
$ awsl cloudwatch describe-alarms \
    --query 'MetricAlarms[*].[AlarmName,StateValue]' --output table

スクリーンショットを撮ってください: 03_alarm_states.png describe-alarms の出力で、INSUFFICIENT_DATA と ALARM と OK が混在しているところが 写るようにしてください。状態が3つあることが伝わる画面にしてください。


⑥ サービスクォータ — 当たってから知る

ここまでは「見えるようにする」話でした。 ⑥は「見えないまま壁に当たる」話です。

何が起きるか

私が最初にこれに当たったのは、練習用のサーバーを増やそうとしたときです。

An error occurred (VcpuLimitExceeded) when calling the RunInstances operation:
You have requested more vCPU capacity than your current vCPU limit allows ...

「お金を払えば好きなだけ使える」ではありませんでした。

AWS のほぼ全部のサービスに、アカウント単位・リージョン単位の上限があります。 そして、多くは「当たってから」しか知りません。 上限に近づいても、AWS は何も言ってきません。

一覧しようとしてみる

上限を扱う専用のサービスが service-quotas です。

bash
$ awsl service-quotas list-services --max-results 5
An error occurred (InvalidAction) when calling the ListServices operation: ...

正直に書きます。LocalStack のコミュニティ版に Service Quotas は入っていません。 動きません。 エラーの文面は環境で変わりますが、使えないという結論は変わりません。

本物の AWS では、こう打ちます(この記事では実行しません)。

bash
$ # 本物のAWSで実行するコマンド(この記事では打ちません)
$ aws service-quotas list-services --max-results 10
$ aws service-quotas list-service-quotas --service-code ec2
$ aws service-quotas get-service-quota --service-code ec2 --quota-code L-1216C47A

L-1216C47A のような文字列がクォータコードです。 人間が覚えるものではありません。 list-service-quotas の出力から探します。

そして、AWS を触っていない今でもできる、いちばん大事なことがこれです。

公式ドキュメントの「サービスクォータ」ページを、先に読んでおく。 AWS のサービスクォータ(一般リファレンス) に、サービスごとの上限がまとまっています。

読むときの見分け方は1つです。

表記意味
調整可能(Adjustable)申請すれば上げられる。 時間はかかる
調整不可(Not adjustable)絶対に上がらない。 設計を変えるしかない

「調整不可」に当たってから設計を変えるのは、いちばん高くつきます。 先に読んでおくのは、そのためです。

個人開発で当たりやすい上限

上限どこで効くか当たったときの症状
EC2 の vCPU 数(ファミリーごと・リージョンごと)台数を増やしたときVcpuLimitExceeded で起動できない
Lambda の同時実行数アクセスが集中したときスロットリング。 処理が捨てられるか遅延する
リージョンあたりの Elastic IP固定IPを何個も付けたとき割り当てに失敗する
VPC あたりのサブネット数 / ルートテーブル数構成を細かく切ったとき作成が失敗する
S3 のリクエストレート(プレフィックス単位)大量アクセス時503 Slow Down。 落ちたように見える
セキュリティグループのルール数IP を1つずつ許可していったとき追加できなくなる
CloudWatch のカスタムメトリクス数ディメンションを増やしすぎたとき費用として先に効く
アカウントあたりの VPC 数環境を分けたとき作成できない

上から3つは、個人の学習でも普通に当たります。

特に Lambda の同時実行数は、「サーバーレスは勝手にスケールする」の限界です。 無限にはスケールしません。 アカウント単位の上限で頭打ちになります。

引き上げ申請は、必要になる前に出す

クォータの引き上げは、申請してすぐ通るとは限りません。 人の審査が入るものがあり、日をまたぐことがあります。

つまり、こうなります。

  • 「明日イベントだから、今日 vCPU 上限を上げよう」→ 間に合わないことがある
  • 「上限に当たった」ときには、もう遅い

個人開発でも、やることは1つです。

  1. 使うサービスのクォータページを、使い始める前に1回読む
  2. 「調整不可」のものだけメモしておく(設計に影響するのはこれだけ)
  3. 上限に近づいたら気づけるようにする ← 次の話

クォータそのものに、アラームを張れる

Service Quotas は、使用量を CloudWatch メトリクスとして出せます。 つまり「上限の80%に達したら鳴る」アラームが作れます。

本物の AWS では、AWS/Usage という名前空間を使います。

bash
$ # 本物のAWSで実行するコマンド(この記事では打ちません)
$ aws cloudwatch list-metrics --namespace "AWS/Usage" --max-items 5

考え方だけ、LocalStack で真似してみます。 「上限100に対して、いま何個使っているか」を自作メトリクスで持ちます。

bash
$ awsl cloudwatch put-metric-data \
    --namespace "MyApp/Quota" \
    --metric-name VcpuUsed \
    --unit Count \
    --dimensions Region=ap-northeast-1 \
    --value 78
bash
$ awsl cloudwatch put-metric-alarm \
    --alarm-name quota-vcpu-80pct \
    --alarm-description "vCPU usage over 80 percent of limit" \
    --namespace "MyApp/Quota" \
    --metric-name VcpuUsed \
    --dimensions Name=Region,Value=ap-northeast-1 \
    --statistic Maximum --period 300 \
    --threshold 80 --comparison-operator GreaterThanOrEqualToThreshold \
    --evaluation-periods 1 \
    --treat-missing-data notBreaching
bash
$ awsl cloudwatch describe-alarms --alarm-names quota-vcpu-80pct \
    --query 'MetricAlarms[*].[AlarmName,Threshold,ComparisonOperator]' --output table
------------------------------------------------------------------------
|                           DescribeAlarms                             |
+---------------------+---------+------------------------------------- +
|  quota-vcpu-80pct   |  80.0   |  GreaterThanOrEqualToThreshold        |
+---------------------+---------+------------------------------------- +

統計に Maximum を選んでいることに注目してください。 ③でやった通り、「一度でも触れたら困るもの」に平均は使いません。

上限は「当たってから知る」ものです。 だから、当たる前に知るための線を、自分で引きます。


⑦ 費用を見る — 請求メトリクスと Budgets

最後に、費用の見方を整理します。

これは「1台目を立てる前」にやることです。 本線の クラウド料金は止め忘れで膨らむ — 先に上限を作る で、先に上限を作る話をしました。この節は、その CloudWatch 側の中身です。

請求メトリクスの、有名な罠

AWS には AWS/Billing という名前空間があり、EstimatedCharges というメトリクスが入ります。 「見積もり請求額」です。

ここに、非常に有名な罠があります。

請求メトリクスは、バージニア北部(us-east-1)にしか存在しません。 東京リージョン(ap-northeast-1)で AWS/Billing を探しても、1つも出てきません。

東京でサーバーを動かしていても、です。 請求はアカウント全体で1つなので、集約先が1リージョンに固定されているためです。

さらに、もう1つあります。

請求メトリクスは、既定では有効になっていません。 アカウント設定で「請求アラートを受け取る」を有効にして初めて、データが流れ始めます。 有効にする前の期間のデータは、遡って取れません。

LocalStack で形だけ真似すると、こうなります。

bash
$ awsl cloudwatch put-metric-data \
    --namespace "AWS/Billing" \
    --metric-name EstimatedCharges \
    --unit None \
    --dimensions Currency=USD \
    --value 12
bash
$ awsl cloudwatch put-metric-alarm \
    --alarm-name billing-alert \
    --alarm-description "estimated charges over threshold" \
    --namespace "AWS/Billing" \
    --metric-name EstimatedCharges \
    --dimensions Name=Currency,Value=USD \
    --statistic Maximum --period 21600 \
    --threshold 10 --comparison-operator GreaterThanThreshold \
    --evaluation-periods 1 \
    --treat-missing-data notBreaching
bash
$ awsl cloudwatch describe-alarms --alarm-names billing-alert \
    --query 'MetricAlarms[*].[AlarmName,Namespace,Period]' --output table
-----------------------------------------------------
|                 DescribeAlarms                    |
+------------------+---------------+----------------+
|  billing-alert   |  AWS/Billing  |  21600         |
+------------------+---------------+----------------+

--period 21600(6時間)にしているのは、請求メトリクスの更新が数時間おきだからです。 60秒にすると、ほとんどの期間がデータ無しになります。

しきい値の 10 は、この記事の例として置いた数字です。 実際にいくらにするかは、公式の CloudWatch の料金 と 自分の予算で決めてください。この記事では金額の目安を書きません。

CloudWatch 請求アラームと AWS Budgets の違い

似た2つがあるので、表で分けます。

CloudWatch 請求アラームAWS Budgets
見るものいま時点の見積もり請求額予算に対する実績と、月末の予測
置き場所us-east-1 のみリージョンに依存しない
事前準備請求アラートの有効化が要る特になし
「使いすぎそう」の予測できない(超えてから鳴る)できる(予測で鳴らせる)
サービス単位・タグ単位の内訳苦手得意
通知SNS 経由メール / SNS
課金アラーム自体に課金一定数まで無料枠あり(公式 を参照)

どちらか片方なら Budgets です。 「超えてから鳴る」より「超えそうだと鳴る」ほうが、止められるからです。

ただし、どちらも「止めて」はくれません。通知するだけです。 AWS に「全部を自動で止める」スイッチはありませんが、Budgets の予算アクションで IAM ポリシーの適用や指定した EC2/RDS の停止は自動化できます。 止めるのは自分です。

CloudWatch 自体が課金対象

最後に、いちばん忘れがちなことです。

監視を増やすと、監視の費用が増えます。

課金されるものの構造だけ挙げます。金額は公式の料金ページを見てください。

課金の対象何で増えるか個人開発で効くか
カスタムメトリクスの数ディメンションの組み合わせの数効く。いちばん危ない
API 呼び出し回数put-metric-data / get-metric-* の回数効く(③でやった100回のようなもの)
ログの取り込み量出したログの量効く。DEBUG を出しっぱなしにすると跳ねる
ログの保管量保持期間 × 取り込み量効く。既定が無期限なので
Logs Insights のスキャン量クエリが読んだデータ量効く(範囲を絞らないクエリ)
アラームの数作った数(高解像度は別料金)少なければ小さい
ダッシュボード枚数少なければ小さい

そして、この記事の最初に戻ります。

「全部を細かく取る」は、費用で跳ね返ります。

具体的には、この2つを避けます。

  1. ディメンションに、値の種類が多いものを入れない。

user_id や request_id をディメンションにすると、ユーザー数だけメトリクスが増えます。 それはログでやるべきことです(④の request_id はログのフィールドであって、ディメンションではありません)

  1. 収集間隔を、意味も無く短くしない。

10秒間隔は60秒間隔の6倍の点を作ります。6倍速く気づけるわけではありません(気づく速さはアラームの評価期間で決まる)

判断表 — 何を、どこで見るか

知りたいこと使うもの統計備考
CPU が張り付いていないか標準メトリクスAverage + Maximumエージェント不要
メモリが足りているかエージェントMaximum標準では取れない
ディスクが埋まっていないかエージェントMaximum標準では取れない
遅いユーザーがいないかカスタムメトリクスp95 / p99平均では見えない
エラーが増えていないかカスタムメトリクス or ログSum
「あのリクエスト」で何が起きたかログ(JSON)—request_id が要る
どのパスが遅いかLogs Insightspct(...,95)構造化が前提
サーバーが生きているかアラームtreat-missing-data breaching「来ない=異常」
上限に近づいていないかクォータ + アラームMaximum当たる前に線を引く
使いすぎていないかBudgets—予測で鳴らせる

つまずいたところ

1. get-metric-statistics が、エラーも出さずに空を返した

ディメンションの指定が put 側と一致していませんでした。 put は --dimensions Service=api,Env=prod、get は --dimensions Name=Service,Value=api Name=Env,Value=prod で、書式が違います。 エラーにならないので、コマンドが間違っていることに気づけません。 まず list-metrics で、実際に登録されているディメンションを見るのが最短でした。

2. 「メモリのメトリクスが見つからない」で30分探した

無いものを探していました。 名前を間違えているのだと思って、 MemoryUtilization、MemUsed、mem_used_percent と総当たりしました。全部ありません。 そもそも標準では存在しないというのが答えでした。 「探しても無いときは、名前を疑う前に、そもそも存在するかを疑う。」

3. 平均で見て「問題なし」と報告してしまった

応答時間の平均が 288ms だったので「速い」と書きました。 同じデータの p95 は 2140ms でした。 20人に1人が2秒待っていました。 「平均は、外れ値を薄めるための道具だ」と気づくまで、自分の報告が嘘だと分かりませんでした。

4. 統計セットにしたら、p95 が出せなくなった

API 呼び出し回数を減らそうと --statistic-values に切り替えたら、 --extended-statistics p95 が何も返さなくなりました。 元の1件1件を捨てているので、後からパーセンタイルは計算できません。 「回数を減らす」と「分布を見る」は両立しません。 先に決める必要がありました。

5. ログの保持期間を設定し忘れていた

describe-log-groups の retentionInDays が None なのを、 「まだ設定されていないだけ」だと思っていました。 それが「無期限」という設定でした。 ロググループを作った直後に put-retention-policy を打つ、を手順に組み込みました。

6. filter-log-events の JSON フィルタが効かなかった

LocalStack のコミュニティ版では、--filter-pattern '{ $.status = 500 }' が期待通りに動きませんでした。 最初は自分の書き方が悪いのだと思って1時間ほど直していました。 LocalStack 側の実装差だと分かってから、jq で確かめる方針に切り替えました。 「動かないときに、自分のコードだけを疑わない」 は、 エミュレータを使うときの基本でした。

7. アラームを作ったのに、いつまでも INSUFFICIENT_DATA から動かなかった

LocalStack のコミュニティ版には、アラームを定期評価するエンジンがありません。 メトリクスを何度送っても、状態は変わりません。 set-alarm-state で手動で動かす、が正解でした。 本物の AWS でも、通知経路のテストにはこれを使います。

8. 「請求メトリクスが1つも出てこない」

東京リージョンで探していました。 AWS/Billing は us-east-1 にしかありません。 さらに、アカウント設定で請求アラートを有効にしないと、そもそもデータが流れません。 「リージョンを疑う」は、AWS のトラブルシュートで最初に確認する項目の1つです。


後片づけ

練習で作ったものを、全部消します。

まず、LocalStack の中のリソースを消してみます(片づけ方を覚えるため)。

bash
$ awsl cloudwatch delete-alarms --alarm-names service-degraded
$ awsl cloudwatch delete-alarms \
    --alarm-names latency-high latency-sustained error-rate-high quota-vcpu-80pct billing-alert
$ awsl cloudwatch describe-alarms --query 'MetricAlarms[*].AlarmName' --output text

複合アラームを先に消します。 子アラームを先に消そうとすると、 参照されているために失敗することがあります。

ログを消します。

bash
$ awsl logs delete-log-group --log-group-name /myapp/app
$ awsl logs delete-log-group --log-group-name /myapp/json
$ awsl logs describe-log-groups --query 'logGroups[*].logGroupName' --output text

メトリクスは、個別に削除する API がありません。 送ったデータは保持期間が過ぎるまで残ります。(本物の AWS でも同じです) だから、⑦で書いた「増やしすぎない」が効いてきます。

最後に、LocalStack ごと消します。

bash
$ cd ~/awslab/cw
$ docker compose down -v
$ docker compose ps
NAME   IMAGE   STATUS   PORTS

-v を付けないと、./volume に対応するボリュームが残ります。 Docker のボリュームは、コンテナを消しても残るためです。

作業ディレクトリも消します。

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

rm -rf はパスを2回読んでから打ってください。 消したものは戻りません。

そして、これは念のためですが。

この記事では本物の AWS に1度も繋いでいないので、課金は発生していません。 aws configure に入れた test という文字列も、本物の認証情報ではありません。


まとめ — 理解できたこと

  • AWS が標準で見ているのは「箱の外側」だけ。 CPU・ネットワーク・ディスクI/Oは

ハイパーバイザーから測れるが、メモリ・ディスクの空き・プロセスは、中に入らないと分からない

  • メモリ使用率とディスク使用率は、CloudWatch の標準メトリクスに存在しない。

取り忘れではなく構造上そうなっている。 エージェントを入れるまで、永久に出てこない

  • 「CPU は正常なのに落ちた」は、見ていなかったのではなく、見えていなかった。

監視の穴は、グラフの中ではなく、グラフの外にある

  • CloudWatch のメトリクスは、名前空間・名前・ディメンションの3点で1本になる。

ディメンションが1文字違えば別の線で、get で指定を間違えるとエラーも出さずに空が返る

  • 同じ100件のデータでも、平均 288ms・p95 2140ms・最大 4886ms と桁が変わる。

平均だけ見ていると、20人に1人が2秒待っているのが見えない

  • メモリとディスクは Maximum で見る。 平均が 60% でも、1分だけ 100% になれば死ぬ
  • API 呼び出しを減らす統計セットを使うと、パーセンタイルが出せなくなる。

「回数」と「分布」はトレードオフで、先に決めるしかない

  • ログの保持期間の既定は「無期限」。 ロググループを作ったら、次の1コマンドで保持期間を入れる
  • 構造化ログ(JSON)にしないと、後から数字として集計できない。

素のテキストで出したログは、正規表現で救うしかなくなる。1行目から JSON で出す

  • 全部のログ行に request_id を入れておかないと、「あのリクエストで何が起きたか」を追えない
  • アラームの状態は3つ。 INSUFFICIENT_DATA は「まだ大丈夫」ではなく「分からない」で、

サーバーが完全に死んだときはこれになる。 --treat-missing-data で意味を決める

  • 3 out of 5 のような設定で、一瞬のスパイクでは鳴らないようにする。

うるさいアラームは3日で切られる。切られたアラームは、無いのと同じ

  • 複合アラームで「2つ同時に悪いときだけ鳴らす」「メンテ中は鳴らさない」ができる
  • AWS のほぼ全部に上限がある。多くは当たってから知る。

「調整可能」か「調整不可」かを先に読み、引き上げ申請は必要になる前に出す

  • 上限にもアラームを張れる。 当たってからでは遅いので、当たる前に線を引く
  • 請求メトリクスは us-east-1 にしかなく、既定では無効。

「超えてから鳴る」CloudWatch 請求アラームより、「超えそうで鳴る」Budgets のほうが役に立つ

  • どちらも止めてはくれない。通知するだけ。止めるのは自分
  • CloudWatch 自体が課金対象。 カスタムメトリクスの数・ログの取り込み量・保管量で増える。

「全部を細かく取る」は費用で跳ね返る

  • LocalStack のコミュニティ版では、Logs Insights とサービスクォータは動かず、アラームの自動評価も無い。エミュレータで動かないことは、自分のコードの誤りではない

参考リンク


次に読む

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

記事
← 前の記事AWSでコンテナを動かす選択肢 — Kubernetesを選ぶ理由がない
→ 次の記事SESでメールを送る — バウンスを放置すると送信が止まる

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

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

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

AWS›AWS — Monitoring & Quotas
  • メモリは標準では取れない
  • 上限は当たってから知ることになる

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

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

コメント

コメントする

目次