IAMのポリシーとロールを読む — AccessDeniedに全権限で答えない

IAMのポリシーとロール。利用者のカードとポリシーの文書、権限を表す鍵。

AccessDenied に全権限で答えてはいけません。IAMのポリシーとロールを読めるようにして、必要な権限だけ足します。

前回: クラウドとは何か・責任共有モデル — 借りても責任は消えない

これは【深掘り】の記事です。本線の順路ではありません。 読まなくても先へ進めます。 本線の EC2は立てて壊す教材 — AWSの最初の1台 の続きとして、そこでは「動けばよい」で流した 「誰が何をしてよいかを、誰がどう決めているのか」 を、実際に手で作って確かめる回です。


このAWS深掘りシリーズは、読者にAWSアカウントを作らせません。

– 触るのは LocalStack(自分のVMの中で動く、AWSのAPIの真似をするソフト)と、aws CLI の --endpoint-url 指定だけです。通信は自分のVMの外へ出ません – 課金が発生する操作は、この記事では一切やりません。 出てくるアクセスキーもアカウントIDも、すべてLocalStackが返すダミーです – 料金の金額は書きません。 書くのは「何に対して課金されるのか」という構造だけです。金額は変わるので、必ずAWSの公式料金ページで自分で確かめてください – 最後に docker compose down -v で練習場ごと消します – なお LocalStack は2026年3月23日から1つのイメージに統合され、それ以降の版(2026.03.0 以降)は起動に auth token(LocalStack のアカウントで取得。無料プランあり)が必要になりました。 この記事では、統合前に公開されて更新が止まった localstack/localstack:3 を固定して使い、アカウントを作らずに進めます。旧イメージの固定は練習用の短期的な手段です(公式は、更新が来ない・修正済みの脆弱性が残ると注意しています)。新しい版を使う場合は、取得した token を LOCALSTACK_AUTH_TOKEN 環境変数に設定します。

この記事は「守る側」だけを書きます。 権限を広げる抜け道、鍵を手に入れる手順、他人の設定を調べる方法は一切書きません。 書くのは自分の設定が効いているかを、自分で確かめる方法だけです。

コマンドを打つ場所: この記事のコマンドは、断りがない限りすべてVMの中(Ubuntu Server) で打ちます。Windows の PowerShell では何もしません。 前提: コンテナは軽い仮想マシンではない — Dockerの導入とComposeなら1コマンドを終えて、docker compose version が返ること。

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

目次

私がやらかしたこと

本線のEC2の回のあと、ファイルを置く練習をしていたときのことです。

コマンドを打つと、こう返ってきました。

An error occurred (AccessDenied) when calling the PutObject operation:
Access Denied

私はここで、原因を調べませんでした。

調べる代わりにやったことは、こうです。「全部できる」ポリシーを1枚作って、それを自分に付けました。

{
  "Effect": "Allow",
  "Action": "*",
  "Resource": "*"
}

通りました。 その日の作業は終わりました。そして、何が足りなかったのかは、いまでも分かっていません。

これはあとから考えると、2つのことを同時にやっていました。

  1. 問題を解いていない。 足りなかった1つの権限が何だったのか、私は最後まで知らない
  2. 「調べるのが面倒だ」という理由だけで、被害の上限を最大にした。 この鍵が漏れたとき、失われるのはそのアカウントで触れるもの全部になった

しかも私は、そのときのアクセスキーを、サーバーの .env に書いて置いていました。 期限はありません。置いた瞬間から、消すまでずっと有効です。

この2つが、初心者がAWSで最初にやる最大の失敗だと、いまは思っています。そして両方とも、IAMという1つの仕組みを「設定項目の集まり」だと思っていたことから来ています。

IAMは設定画面ではありません。1つの判定エンジンです。 何かを叩くたびに、毎回それが動いて yes / no を出しています。 中で何を見て判定しているかが分かれば、AccessDenied は「調べられるもの」になります。

この記事は、その判定エンジンの中身を、自分の手で組み立てて確かめる回です。 アカウントは作りません。課金もしません。

この記事でわかること

  • IAMが答えている問いは1つだけだということ。「この主体は、この操作を、この資源に対してやってよいか」。ポリシーに書いてあるのはこの3つとその答えが全部で、それ以外は無い
  • 判定の順番は「明示的なDeny > 明示的なAllow > 暗黙のDeny」で固定だということ。Allow をいくら足しても、Deny が1つあれば絶対に通らない
  • AccessDenied のメッセージの末尾が、どこで落ちたかを教えていること。explicit deny in an identity-based policy と because no identity-based policy allows は、まったく違う原因で、直す場所も違う
  • 権限は「ユーザー側に貼る」以外に「資源側に貼る」があること。バケット側から許可を出すこともできるので、ユーザーのポリシーだけ見ても答えは出ない
  • ロールにはパスワードもアクセスキーも無いこと。「一時的に借りる権限」で、取り出した認証情報には必ず有効期限が付いている
  • サーバーにアクセスキーを置かなくてよくなる唯一の正解が、インスタンスプロファイルだということ。鍵を配らずに権限を渡せる
  • Action のワイルドカード s3:* が、実際には何を許してしまうのか。「読むだけのつもり」がどこまで含むか

この記事でやること

  1. LocalStackで練習場を1つ立てる(~/awslab/iam)。AWSアカウントは作らない。課金もしない
  2. ユーザーとグループを作り、権限をユーザーではなくグループに付ける。list-groups-for-user で結び付きを確認する
  3. 最小権限のポリシーを自分でJSONで書いて create-policy で登録し、get-policy-version で読み返す
  4. AllowとDenyを両方持つポリシーを作り、simulate-principal-policy で判定結果を出す。 そのうえで実際に AccessDenied を出して、メッセージの末尾を読む
  5. S3のバケットポリシー(資源側)を作り、資源の側から許可が出せることを確かめる
  6. ロールを作り、sts assume-role で一時的な認証情報を取り出して、有効期限が付いているのを目で見る
  7. インスタンスプロファイルを作り、ロールを入れる。 なぜこれが「鍵を置かない」正解なのかを整理する
  8. docker compose down -v で全部消す

先に知る言葉

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

言葉意味
IAMIdentity and Access Management。「誰が何をしてよいか」を判定する仕組み。AWSのほぼ全ての操作が、必ずここを通る
主体(Principal)操作しようとしている当人。 ユーザー、ロール、または他のAWSサービス
アクション(Action)やろうとしている操作。 s3:GetObject のように サービス名:操作名 の形で書く
リソース(Resource)操作の対象。 バケット、その中のファイル、EC2の1台など。ARNという形式で指す
ARNAmazon Resource Name。AWSの中の物ひとつひとつに付く住所。arn:aws:s3:::バケット名/ファイル名 の形
ポリシー「誰が・何を・どれに・してよいか(あるいはダメか)」を書いたJSONの紙。IAMが読むのはこれだけ
ロール(Role)一時的に借りる権限の入れ物。 パスワードもアクセスキーも持たない。借りると期限付きの認証情報がもらえる
AssumeRoleロールを借りる操作。 これを呼ぶと期限付きの鍵が返ってくる
STSSecurity Token Service。その期限付きの鍵を発行する係のサービス
インスタンスプロファイルEC2にロールを持たせるための包み。これがあるとサーバーにアクセスキーを置かなくてよくなる
LocalStackAWSのAPIの真似を、自分のPCの中で動かすソフト。 本物には繋がらないので課金されない
ルートユーザーアカウントを作ったときの最初の1人。 何でもできてしまうので日常的に使ってはいけない

① IAMが答えている問いは、たった1つ

最初に言い切ります。

IAMは、次の1つの問いにしか答えていません。

この主体(誰が)は、この操作(何を)を、この資源(どれに対して)やってよいか?

この3つが、ポリシーの全部です。 画面にどれだけ項目が並んでいても、IAMが判定に使っているのはこの3つと、その答え(AllowかDenyか)だけです。

図にするとこうです。

    誰が          何を                 どれに
  Principal  ×   Action        ×    Resource
     |             |                    |
  dummy-dev-taro  s3:GetObject   arn:aws:s3:::dummy-report-bucket/report.csv
     |             |                    |
     +-------------+--------------------+
                   |
            [ IAM の判定エンジン ]
                   |
              Allow  /  Deny

そしてもう1つ、後で効いてくる4つ目があります。

要素役割必須か
EffectAllow か Deny か。答えそのもの必須
Action何をするか必須
Resourceどれに対してかほぼ必須
Principal誰が。ユーザー側に貼るポリシーでは省略する(貼った相手が主体だから)場合による
Condition「〜のときだけ」という追加条件。時間帯、接続元、通信の暗号化の有無など任意

「ユーザー側に貼るポリシーでは Principal を書かない」 ここが最初に混乱するところです。貼った相手が主体だから、書く必要がないのです。逆に資源側に貼るポリシー(後述)では、Principal を書かないと誰の話か分かりません。

この「3つ+Effect+Condition」以外は、IAMには存在しません。 ここを押さえたうえで、実際に作っていきます。

② 練習場を1つ立てる(AWSアカウントは作らない)

AWSのアカウントは作りません。 代わりに、AWSのAPIの真似をするLocalStackを、自分のVMの中で1つ動かします。

なぜアカウントを作らないのか。 IAMの練習で怖いのは、「間違えて権限を広く付けたまま忘れる」ことと、「練習で作ったアクセスキーを消し忘れる」ことです。本物のアカウントが無ければ、どちらも起こりません。

作業場を作る

bash
$ mkdir -p ~/awslab/iam
$ cd ~/awslab/iam

この記事で作るファイルは、全部この1つのフォルダの中にだけ作ります。 最後にフォルダごと消します。

compose.yaml を書く

bash
$ nano compose.yaml
services:
  localstack:
    image: localstack/localstack:3
    container_name: awslab-iam
    ports:
      - "4566:4566"
    environment:
      - SERVICES=iam,sts,s3
      - ENFORCE_IAM=1
      - DEBUG=1
    volumes:
      - localstack-data:/var/lib/localstack

volumes:
  localstack-data:

行の意味です。

行意味
image: localstack/localstack:3LocalStackの3系。タグを固定する。latest にすると、あとで読み返したとき出力が変わる
ports: 4566:4566AWSの全サービスがこの1つのポートで受け付ける。サービスごとにポートは分かれない
SERVICES=iam,sts,s3今日使うのはこの3つだけ。起動が軽くなる
ENFORCE_IAM=1これが今日の要。既定のLocalStackは権限を判定せず、何でも通してしまう。これを付けて初めて AccessDenied が出る
localstack-data作ったユーザーやポリシーの保存先。down -v で消えるのはここ

起動する

bash
$ docker compose up -d
[+] Running 3/3
 ✔ Network iam_default          Created
 ✔ Volume "iam_localstack-data" Created
 ✔ Container awslab-iam         Started

動いているか確かめます。

bash
$ curl -s http://localhost:4566/_localstack/health
{"services": {"iam": "available", "s3": "available", "sts": "available"}, "edition": "community", "version": "3.8.1"}

ここで available が返らなければ、先へ進んでも全部失敗します。 30秒ほど待ってもう一度打ってください。

aws CLI を入れる(公式インストーラで v2)

bash
$ sudo apt update
$ # Ubuntu 24.04 の apt には awscli が無い(22.04 でも v1)ので、AWS 公式の zip で v2 を入れる
$ sudo apt install -y unzip curl
$ curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o awscliv2.zip
$ unzip -q awscliv2.zip
$ sudo ./aws/install
$ aws --version
aws-cli/2.15.30 Python/3.11.8 Linux/6.8.0-45-generic

ダミーの認証情報を入れる

AWS CLIは、認証情報が設定されていないと動きません。 ただしLocalStackは中身を見ていないので、適当な文字列で構いません。

bash
$ export AWS_ACCESS_KEY_ID=test
$ export AWS_SECRET_ACCESS_KEY=test
$ export AWS_DEFAULT_REGION=ap-northeast-1

test という文字列は、LocalStackが公式に案内しているダミー値です。 本物のアクセスキーを、ここに絶対に入れないでください。 本物を入れると、以降のコマンドが本物のAWSに向かってしまう危険があります(--endpoint-url の付け忘れが1回でもあれば起きます)。

毎回打つのが長いので、短縮する

この先、全部のコマンドに --endpoint-url=http://localhost:4566 が付きます。 短くします。

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

awsl は「LocalStack向けのaws」という意味で私が付けた名前です。 一般的な名前ではありません。この別名は端末を閉じると消えます。 それでよいです(残ると事故のもとになるため、あえて .bashrc には書きません)。

確認します。

bash
$ awsl sts get-caller-identity
{
    "UserId": "AKIAIOSFODNN7EXAMPLE",
    "Account": "000000000000",
    "Arn": "arn:aws:iam::000000000000:root"
}

Account が 000000000000 になっているのがLocalStackの目印です。 本物のAWSなら12桁の数字が入ります。この0が並んでいる限り、あなたは本物には触っていません。

そしてもう1つ。Arn の末尾が root です。 いま私たちはルートユーザーとして操作しています。本物のAWSではこれをやってはいけません(⑨で書きます)。練習場だから許されている状態です。

[スクリーンショット: 01_localstack-health.png]

_localstack/health の出力と get-caller-identity の 000000000000 が両方見えている画面。「本物に繋がっていない」ことの証拠として撮っておきます。

③ ユーザーとグループを作る(権限はユーザーに直接付けない)

まずユーザーを1人作ります。

bash
$ awsl iam create-user --user-name dummy-dev-taro
{
    "User": {
        "Path": "/",
        "UserName": "dummy-dev-taro",
        "UserId": "s6vzy0h8k1r2m4n7p9qa",
        "Arn": "arn:aws:iam::000000000000:user/dummy-dev-taro",
        "CreateDate": "2026-10-05T09:12:44.512000+00:00"
    }
}

dummy- で始まる名前は、私が適当に付けたものです。 本物の同僚の名前やアカウント名を、この練習に混ぜないでください。

Arn に注目してください。

arn:aws:iam::000000000000:user/dummy-dev-taro
 |   |   |        |          |
 |   |   |        |          +-- 資源の種類と名前
 |   |   |        +------------- アカウントID
 |   |   +---------------------- サービス名(iam)
 |   +-------------------------- パーティション(aws)
 +------------------------------ 固定の接頭辞

これがこの人の住所です。 ポリシーで「誰が」を指すときは、名前ではなくこのARNで指します。

ここで、やってはいけないほうをまず見る

このユーザーに、直接ポリシーを付けることができます。 実際、AWSの画面でも数クリックでできます。

でも、やりません。理由は1つです。

人が増えたときに破綻するからです。

やり方3人のとき30人になったとき1人辞めたとき
ユーザーに直接付ける3人×5ポリシー = 15回の作業150回の作業どのポリシーが本人だけのものか、誰も分からない
グループに付けるグループ1つに5ポリシー = 5回5回のままグループから外すだけ

「人が3人しかいないから直接でいい」は、3人のうちにやるから楽なのであって、30人になってからは直せません。 最初からグループにします。

グループを作る

bash
$ awsl iam create-group --group-name dummy-developers
{
    "Group": {
        "Path": "/",
        "GroupName": "dummy-developers",
        "GroupId": "hp3d9k2m5n8q1r4t7wxz",
        "Arn": "arn:aws:iam::000000000000:group/dummy-developers",
        "CreateDate": "2026-10-05T09:14:02.771000+00:00"
    }
}

ユーザーをグループに入れる

bash
$ awsl iam add-user-to-group \
    --group-name dummy-developers \
    --user-name dummy-dev-taro

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

結び付いたか確かめます。

bash
$ awsl iam list-groups-for-user --user-name dummy-dev-taro
{
    "Groups": [
        {
            "Path": "/",
            "GroupName": "dummy-developers",
            "GroupId": "hp3d9k2m5n8q1r4t7wxz",
            "Arn": "arn:aws:iam::000000000000:group/dummy-developers",
            "CreateDate": "2026-10-05T09:14:02.771000+00:00"
        }
    ]
}

入りました。 この時点で dummy-developers に何かポリシーを付ければ、dummy-dev-taro にも効きます。

逆向きも確かめられます。 グループに誰が入っているかは get-group です。

bash
$ awsl iam get-group --group-name dummy-developers --query 'Users[].UserName'
[
    "dummy-dev-taro"
]

[スクリーンショット: 02_user-and-group.png]

create-user から list-groups-for-user までの一連の出力。ARNの形が見えるように撮ります。

④ ポリシーの構造を、1行ずつ読む

ここからが本題です。 ポリシーはJSONの紙1枚です。

まず、危ないほうを読む

私が最初にやった「全部Allow」は、こう書かれています。

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "*",
      "Resource": "*"
    }
  ]
}

これは「読み書き全部」ではありません。「このアカウントで存在しうる全ての操作」です。 他人のユーザーを作ることも、請求情報を見ることも、全部のデータを消すことも含みます。

では、1段だけ絞った s3:* はどうでしょうか。 「S3だけだから安全」に見えます。

s3:* に含まれるものを、守る側として並べてみます。

操作何ができてしまうか
s3:GetObject中身を読む
s3:PutObject上書きする(既存のファイルを置き換えられる)
s3:DeleteObject消す
s3:DeleteBucket入れ物ごと消す
s3:PutBucketPolicyその入れ物の許可設定を書き換える(=あとで誰に見せるかを変えられる)
s3:PutBucketAcl公開範囲を変えられる
s3:PutBucketVersioningバージョン管理を止められる(=消した履歴が残らなくなる)
s3:PutLifecycleConfiguration「N日で自動削除」を設定できる(=時限式にデータが消える)

「読むだけのつもり」で s3:* と書くと、消す・公開範囲を変える・履歴を止める、まで全部入ります。

これが、ワイルドカードを1文字書くことの意味です。 * は「便利な省略」ではなく、「まだ知らない操作も含めて全部」です。AWSが新しい操作を追加したら、それも自動的に含まれます。

最小権限のポリシーを、自分で書く

「dummy-report-bucket というバケットの中身を読むだけ」 を書きます。

bash
$ nano policy-readonly.json
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "ListTheBucketItself",
      "Effect": "Allow",
      "Action": [
        "s3:ListBucket"
      ],
      "Resource": "arn:aws:s3:::dummy-report-bucket"
    },
    {
      "Sid": "ReadObjectsInThatBucket",
      "Effect": "Allow",
      "Action": [
        "s3:GetObject"
      ],
      "Resource": "arn:aws:s3:::dummy-report-bucket/*"
    }
  ]
}

1つずつ読みます。

キー意味注意
Versionポリシー言語の版。日付ではない2012-10-17 固定。今日の日付を書かない
Statement判定の単位の配列。1つのポリシーに複数入る各要素が独立に評価される
Sidその要素に付ける名札。任意後で「どれで落ちたか」を追うのに効くので書く
EffectAllow か Denyこれが答えそのもの
Actionサービス名:操作名。配列で複数書けるs3:Get* のような部分ワイルドカードも書ける
ResourceARNで対象を指すここが今日いちばん間違えやすい

Resource が2つある理由(ここで必ずつまずく)

同じバケットなのに、ARNが2つあります。

ARN何を指すかどのActionに要るか
arn:aws:s3:::dummy-report-bucket入れ物そのものs3:ListBucket(中に何があるか一覧する)
arn:aws:s3:::dummy-report-bucket/*中に入っている一つ一つのファイルs3:GetObject(1つ読む)

/* を付けたほうだけ書くと、「ファイルは読めるのに一覧が出せない」という状態になります。 逆に /* 無しだけだと、「一覧は出るのに1つも開けない」です。

私はこれで30分溶かしました。 AccessDenied が出るのに、ポリシーには s3 と書いてあるので、目が滑ります。

登録する

bash
$ awsl iam create-policy \
    --policy-name dummy-s3-readonly-one-bucket \
    --policy-document file://policy-readonly.json
{
    "Policy": {
        "PolicyName": "dummy-s3-readonly-one-bucket",
        "PolicyId": "ANPAJ2K4M6P8R1T3V5X7Z",
        "Arn": "arn:aws:iam::000000000000:policy/dummy-s3-readonly-one-bucket",
        "Path": "/",
        "DefaultVersionId": "v1",
        "AttachmentCount": 0,
        "PermissionsBoundaryUsageCount": 0,
        "IsAttachable": true,
        "CreateDate": "2026-10-05T09:21:18.004000+00:00",
        "UpdateDate": "2026-10-05T09:21:18.004000+00:00"
    }
}

AttachmentCount: 0 に注目してください。 作っただけでは、誰にも効いていません。 ポリシーは紙で、貼って初めて効きます。

読み返す

「いま登録されているのは本当にこれか」を、AWS側から取り出して確かめます。

bash
$ awsl iam get-policy-version \
    --policy-arn arn:aws:iam::000000000000:policy/dummy-s3-readonly-one-bucket \
    --version-id v1
{
    "PolicyVersion": {
        "Document": {
            "Version": "2012-10-17",
            "Statement": [
                {
                    "Sid": "ListTheBucketItself",
                    "Effect": "Allow",
                    "Action": ["s3:ListBucket"],
                    "Resource": "arn:aws:s3:::dummy-report-bucket"
                },
                {
                    "Sid": "ReadObjectsInThatBucket",
                    "Effect": "Allow",
                    "Action": ["s3:GetObject"],
                    "Resource": "arn:aws:s3:::dummy-report-bucket/*"
                }
            ]
        },
        "VersionId": "v1",
        "IsDefaultVersion": true,
        "CreateDate": "2026-10-05T09:21:18.004000+00:00"
    }
}

手元のファイルではなく、登録された中身を読み返すことに意味があります。 ファイルは編集したのに登録し直していない、という事故が起きます(⑧のつまずきに書きます)。

グループに貼る

bash
$ awsl iam attach-group-policy \
    --group-name dummy-developers \
    --policy-arn arn:aws:iam::000000000000:policy/dummy-s3-readonly-one-bucket

貼れたか確認します。

bash
$ awsl iam list-attached-group-policies --group-name dummy-developers
{
    "AttachedPolicies": [
        {
            "PolicyName": "dummy-s3-readonly-one-bucket",
            "PolicyArn": "arn:aws:iam::000000000000:policy/dummy-s3-readonly-one-bucket"
        }
    ],
    "IsTruncated": false
}

ユーザーには何も貼っていません。 それでも dummy-dev-taro はこの権限を持ちます。グループ経由だからです。

⑤ 判定の順番と、AccessDenied の読み方

ここが、この記事でいちばん重要なところです。

順番は3段で、固定されている

IAMは、次の順番で判定します。この順番は変えられません。

   1. 明示的な Deny  があるか?  --- あれば  ==> 拒否 (ここで終わり)
              |なし
   2. 明示的な Allow があるか?  --- あれば  ==> 許可
              |なし
   3. 暗黙の Deny (何も書いていない)      ==> 拒否

言い換えると、こうです。

状態結果ひとこと
Allowが1つ、Denyが0許可ふつう
Allowが0、Denyが0拒否何も書かなければ拒否。これが「暗黙のDeny」
Allowが5つ、Denyが1つ拒否Allowをいくら足しても勝てない
Allowが0、Denyが1つ拒否当然

「権限が足りないからAllowを足す」が効かないことがあるのは、これが理由です。Denyが1つでもあれば、Allowを何枚貼っても通りません。

そして私が最初にやった「全部Allow」は、この表の3行目の相手には無力です。 効かない場合があるのに、被害の上限だけが上がる。 最悪の手です。

実際に、両方持つポリシーを作る

「このバケットは読み書きしてよい。ただし削除だけは絶対にダメ」 を書きます。

bash
$ nano policy-nodelete.json
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "AllowReadWriteOnReportBucket",
      "Effect": "Allow",
      "Action": [
        "s3:ListBucket",
        "s3:GetObject",
        "s3:PutObject",
        "s3:DeleteObject"
      ],
      "Resource": [
        "arn:aws:s3:::dummy-report-bucket",
        "arn:aws:s3:::dummy-report-bucket/*"
      ]
    },
    {
      "Sid": "NeverAllowDelete",
      "Effect": "Deny",
      "Action": [
        "s3:DeleteObject",
        "s3:DeleteBucket"
      ],
      "Resource": [
        "arn:aws:s3:::dummy-report-bucket",
        "arn:aws:s3:::dummy-report-bucket/*"
      ]
    }
  ]
}

わざと矛盾させています。 1つ目のStatementで s3:DeleteObject を Allow し、2つ目で同じものを Deny しています。

bash
$ awsl iam create-policy \
    --policy-name dummy-rw-but-never-delete \
    --policy-document file://policy-nodelete.json
{
    "Policy": {
        "PolicyName": "dummy-rw-but-never-delete",
        "PolicyId": "ANPAK5N7Q9S2U4W6Y8B1D",
        "Arn": "arn:aws:iam::000000000000:policy/dummy-rw-but-never-delete",
        "DefaultVersionId": "v1",
        "AttachmentCount": 0,
        "IsAttachable": true,
        "CreateDate": "2026-10-05T09:33:51.220000+00:00",
        "UpdateDate": "2026-10-05T09:33:51.220000+00:00"
    }
}

ユーザーに直接貼ります(今回は実験なので直接貼ります。実務ではグループです)。

bash
$ awsl iam attach-user-policy \
    --user-name dummy-dev-taro \
    --policy-arn arn:aws:iam::000000000000:policy/dummy-rw-but-never-delete

判定させてみる(simulate-principal-policy)

AWSには、「実際にやらずに、判定だけさせる」コマンドがあります。

bash
$ awsl iam simulate-principal-policy \
    --policy-source-arn arn:aws:iam::000000000000:user/dummy-dev-taro \
    --action-names s3:GetObject s3:PutObject s3:DeleteObject s3:DeleteBucket \
    --resource-arns arn:aws:s3:::dummy-report-bucket/report.csv
{
    "EvaluationResults": [
        {
            "EvalActionName": "s3:GetObject",
            "EvalResourceName": "arn:aws:s3:::dummy-report-bucket/report.csv",
            "EvalDecision": "allowed",
            "MatchedStatements": [
                {
                    "SourcePolicyId": "dummy-rw-but-never-delete",
                    "SourcePolicyType": "IAM Policy"
                }
            ],
            "MissingContextValues": []
        },
        {
            "EvalActionName": "s3:PutObject",
            "EvalResourceName": "arn:aws:s3:::dummy-report-bucket/report.csv",
            "EvalDecision": "allowed",
            "MatchedStatements": [
                {
                    "SourcePolicyId": "dummy-rw-but-never-delete",
                    "SourcePolicyType": "IAM Policy"
                }
            ],
            "MissingContextValues": []
        },
        {
            "EvalActionName": "s3:DeleteObject",
            "EvalResourceName": "arn:aws:s3:::dummy-report-bucket/report.csv",
            "EvalDecision": "explicitDeny",
            "MatchedStatements": [
                {
                    "SourcePolicyId": "dummy-rw-but-never-delete",
                    "SourcePolicyType": "IAM Policy"
                }
            ],
            "MissingContextValues": []
        },
        {
            "EvalActionName": "s3:DeleteBucket",
            "EvalResourceName": "arn:aws:s3:::dummy-report-bucket/report.csv",
            "EvalDecision": "explicitDeny",
            "MatchedStatements": [
                {
                    "SourcePolicyId": "dummy-rw-but-never-delete",
                    "SourcePolicyType": "IAM Policy"
                }
            ],
            "MissingContextValues": []
        }
    ]
}

s3:DeleteObject は Allow にも書いてあるのに explicitDeny です。 これが「Denyが勝つ」の実物です。

EvalDecision に出る値は3種類です。

値意味直し方
allowed通る—
explicitDenyどこかにDenyが書いてあるAllowを足しても無駄。Denyを探して外す
implicitDenyどこにも書いていないAllowを足せば通る

この2つのDenyを区別できるかどうかが、AccessDenied を調べられる人と、全権限を付けてしまう人の差です。

simulate が使えないときは、実際に叩く

LocalStackのCommunity版では simulate-principal-policy が実装されていないことがあります。 その場合はこう出ます。

An error occurred (InvalidAction) when calling the SimulatePrincipalPolicy operation:
The action or operation requested is invalid.

そのときは、実際にその権限で操作してみます。 手順はこうです。

まず、そのユーザーのアクセスキーを作ります(LocalStackが返すダミーです)。

bash
$ awsl iam create-access-key --user-name dummy-dev-taro
{
    "AccessKey": {
        "UserName": "dummy-dev-taro",
        "AccessKeyId": "LKIAQAAAAAAAVNCBMPNSG",
        "Status": "Active",
        "SecretAccessKey": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
        "CreateDate": "2026-10-05T09:40:11.930000+00:00"
    }
}

SecretAccessKey はここでしか表示されません。 これは本物のAWSでも同じ仕様です。そして「一度しか見られない値をどこかに保存する」という運用が始まった瞬間から、事故の種になります(⑧で書きます)。

バケットとファイルを1つ用意して、

bash
$ awsl s3 mb s3://dummy-report-bucket
$ echo "date,count" > report.csv
$ awsl s3 cp report.csv s3://dummy-report-bucket/report.csv
make_bucket: dummy-report-bucket
upload: ./report.csv to s3://dummy-report-bucket/report.csv

別の端末を開いて、いま作ったユーザーの鍵に切り替えます。

bash
$ export AWS_ACCESS_KEY_ID=LKIAQAAAAAAAVNCBMPNSG
$ export AWS_SECRET_ACCESS_KEY=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
$ export AWS_DEFAULT_REGION=ap-northeast-1
$ alias awsl='aws --endpoint-url=http://localhost:4566'

読むほうは通ります。

bash
$ awsl s3 cp s3://dummy-report-bucket/report.csv -
date,count

消すほうは落ちます。

bash
$ awsl s3 rm s3://dummy-report-bucket/report.csv
delete failed: s3://dummy-report-bucket/report.csv An error occurred (AccessDenied)
when calling the DeleteObject operation: User: arn:aws:iam::000000000000:user/dummy-dev-taro
is not authorized to perform: s3:DeleteObject on resource:
"arn:aws:s3:::dummy-report-bucket/report.csv" with an explicit deny in an identity-based policy

[スクリーンショット: 03_explicit-deny.png]

読み取りが通り、削除が explicit deny で落ちている2つの出力が並んだ画面。この記事でいちばん大事な1枚です。

AccessDenied のメッセージから、落ちた場所を読む

さっきのメッセージを分解します。

User: arn:aws:iam::000000000000:user/dummy-dev-taro   <- 誰が (Principal)
is not authorized to perform: s3:DeleteObject          <- 何を (Action)
on resource: "arn:aws:s3:::dummy-report-bucket/report.csv"  <- どれに (Resource)
with an explicit deny in an identity-based policy      <- ★ どこで落ちたか

①で言った3つが、そのままメッセージに並んでいます。 そして末尾が、直す場所を教えています。

末尾の文言意味直す場所
with an explicit deny in an identity-based policyユーザー・グループ・ロールに付いたポリシーに Deny があるその人に付いている全ポリシーからDenyを探す。Allowを足しても無駄
with an explicit deny in a resource-based policy資源の側(バケットポリシーなど)に Deny があるバケット側を見る。ユーザーのポリシーをいくら見ても無い
because no identity-based policy allows the ... action暗黙のDeny。どこにも書いていないAllowを足せば通る。ここが本来の「権限が足りない」
with an explicit deny in a service control policy組織全体の制限(SCP)で止められている自分のアカウントでは直せない。組織の管理者に聞く
with an explicit deny in a permissions boundaryその人に設定された上限を超えている上限(permissions boundary)側を見る

この5つは、原因も直し方も全部違います。 私が最初に見た Access Denied は3行目でした。Allowを1つ足せば済んだのに、全部Allowを貼ったわけです。

エラーは下から読む、というのはこの記事にも書きましたが、AWSの場合は文字通り「末尾」に答えが書いてあります。

注意: LocalStackが返すメッセージは、本物のAWSより短いことがあります。 上の表の文言は本物のAWSのものです。LocalStackで Access Denied としか出なくても、本物ではもっと長いと思っておいてください。

この先の作業は、元の端末(ルートの認証情報のほう)に戻って続けます。

⑥ 「ユーザー側に貼る」と「資源側に貼る」

ここまで貼ってきたポリシーは、全部ユーザーやグループの側に貼るものでした。これをアイデンティティベースのポリシーと呼びます。

もう1つあります。 資源の側に貼るポリシーです。S3ならバケットポリシーです。

表で対比する

アイデンティティベースリソースベース
貼る場所ユーザー / グループ / ロールバケット・キューなど資源そのもの
Principal を書くか書かない(貼った相手が主体)必ず書く(誰の話か分からないから)
答えている問い「この人は何をしてよいか」「これに触ってよいのは誰か」
同一アカウント内どちらか一方にAllowがあれば通る同左
別アカウントから両方に必要(相手側にもAllowが要る)両方に必要
数が増えるのは人が増えたとき資源が増えたとき
「誰が触れるか」を1画面で見たい無理(全員分のポリシーを見る必要がある)できる(その資源の紙1枚を見ればよい)

最後の行が、リソースベースの一番の価値です。 「このバケットに触れるのは誰か」を知りたいとき、アイデンティティベースだけだと全員のポリシーを調べる必要があります。

実際に、資源の側から許可を出す

新しいバケットを作って、そこにバケットポリシーを貼ります。

bash
$ awsl s3 mb s3://dummy-shared-bucket
make_bucket: dummy-shared-bucket

別のユーザーを1人作ります。 この人には、ポリシーを1枚も貼りません。

bash
$ awsl iam create-user --user-name dummy-viewer-hanako
{
    "User": {
        "Path": "/",
        "UserName": "dummy-viewer-hanako",
        "UserId": "b2d4f6h8j1l3n5p7r9tv",
        "Arn": "arn:aws:iam::000000000000:user/dummy-viewer-hanako",
        "CreateDate": "2026-10-05T09:52:37.118000+00:00"
    }
}

この状態で、この人は何もできません(暗黙のDeny)。

バケットの側から許可を出します。

bash
$ nano bucket-policy.json
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "LetHanakoReadThisBucketOnly",
      "Effect": "Allow",
      "Principal": {
        "AWS": "arn:aws:iam::000000000000:user/dummy-viewer-hanako"
      },
      "Action": [
        "s3:GetObject"
      ],
      "Resource": "arn:aws:s3:::dummy-shared-bucket/*"
    }
  ]
}

Principal が出てきました。 ここまでのポリシーには一度も書きませんでした。資源の側に貼る紙には、「誰の話か」が必要だからです。

bash
$ awsl s3api put-bucket-policy \
    --bucket dummy-shared-bucket \
    --policy file://bucket-policy.json

貼れたか読み返します。

bash
$ awsl s3api get-bucket-policy --bucket dummy-shared-bucket --query Policy --output text
{"Version": "2012-10-17", "Statement": [{"Sid": "LetHanakoReadThisBucketOnly", "Effect": "Allow", "Principal": {"AWS": "arn:aws:iam::000000000000:user/dummy-viewer-hanako"}, "Action": ["s3:GetObject"], "Resource": "arn:aws:s3:::dummy-shared-bucket/*"}]}

dummy-viewer-hanako には、いまも1枚もポリシーが貼られていません。 確かめます。

bash
$ awsl iam list-attached-user-policies --user-name dummy-viewer-hanako
{
    "AttachedPolicies": [],
    "IsTruncated": false
}
bash
$ awsl iam list-groups-for-user --user-name dummy-viewer-hanako
{
    "Groups": []
}

空です。それでもこの人はこのバケットのファイルを読めます。

これが、守る側にとって重要な事実です。

「このユーザーのポリシーを全部見たから、この人にできることは分かった」は成り立ちません。 資源の側から許可が出ているかもしれないからです。両方見ないと分かりません。

逆に言えば、点検すべき場所が2箇所あるということです。

点検するものコマンド
人の側list-attached-user-policies / list-groups-for-user / list-user-policies
資源の側s3api get-bucket-policy(バケットごとに1つずつ)

⑦ ロールと AssumeRole ここがこのサービスの核心

ここまでは「人」の話でした。 ここからが、IAMがただの権限設定と違うところです。

ロールとは何か

ロールは「一時的に借りる権限」です。

ユーザーと決定的に違うのは、この2つです。

ユーザーロール
パスワードある(画面ログイン用)無い
アクセスキーある。期限が無い無い。借りたときに期限付きの鍵が発行される
誰が使うか決まった1人「借りてよい人」を条件で書く
漏れたとき消すまでずっと有効期限が来れば自然に無効になる

「無い」というのが利点です。 持ち歩く鍵が無いなら、その鍵は漏れません。

誰が借りてよいかを書く(信頼ポリシー)

ロールを作るときには、通常のポリシーとは別に、もう1枚の紙が要ります。

信頼ポリシー(AssumeRolePolicyDocument) です。これは 「このロールを借りてよいのは誰か」 だけを書いた紙です。

bash
$ nano trust-policy.json
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "OnlyEC2CanBorrowThisRole",
      "Effect": "Allow",
      "Principal": {
        "Service": "ec2.amazonaws.com"
      },
      "Action": "sts:AssumeRole"
    }
  ]
}

読み方です。

部分意味
Principal.Service: ec2.amazonaws.com借りてよいのはEC2というサービス。人ではない
Action: sts:AssumeRole「借りる」という操作そのものを許可している
Resource が無い対象はこのロール自身なので書かない

信頼ポリシーは「入口の鍵」、通常のポリシーは「中でできること」です。 2枚とも必要で、役割がまったく違います。

ロールを作る

bash
$ awsl iam create-role \
    --role-name dummy-ec2-app-role \
    --assume-role-policy-document file://trust-policy.json
{
    "Role": {
        "Path": "/",
        "RoleName": "dummy-ec2-app-role",
        "RoleId": "AROAQAAAAAAAY6SBJHXR",
        "Arn": "arn:aws:iam::000000000000:role/dummy-ec2-app-role",
        "CreateDate": "2026-10-05T10:02:55.401000+00:00",
        "AssumeRolePolicyDocument": {
            "Version": "2012-10-17",
            "Statement": [
                {
                    "Sid": "OnlyEC2CanBorrowThisRole",
                    "Effect": "Allow",
                    "Principal": {"Service": "ec2.amazonaws.com"},
                    "Action": "sts:AssumeRole"
                }
            ]
        },
        "MaxSessionDuration": 3600
    }
}

MaxSessionDuration: 3600 に注目してください。 秒です。1時間。 ここに期限が最初から入っています。

中でできることを付けます(③で作った読み取り専用の紙を再利用します)。

bash
$ awsl iam attach-role-policy \
    --role-name dummy-ec2-app-role \
    --policy-arn arn:aws:iam::000000000000:policy/dummy-s3-readonly-one-bucket
bash
$ awsl iam list-attached-role-policies --role-name dummy-ec2-app-role
{
    "AttachedPolicies": [
        {
            "PolicyName": "dummy-s3-readonly-one-bucket",
            "PolicyArn": "arn:aws:iam::000000000000:policy/dummy-s3-readonly-one-bucket"
        }
    ],
    "IsTruncated": false
}

実際に借りてみる

bash
$ awsl sts assume-role \
    --role-arn arn:aws:iam::000000000000:role/dummy-ec2-app-role \
    --role-session-name dummy-session-1
{
    "Credentials": {
        "AccessKeyId": "LSIAQAAAAAAVNCBMPNSG",
        "SecretAccessKey": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
        "SessionToken": "FQoGZXIvYXdzEBYaDdummydummydummydummy...",
        "Expiration": "2026-10-05T11:04:31+00:00"
    },
    "AssumedRoleUser": {
        "AssumedRoleId": "AROAQAAAAAAAY6SBJHXR:dummy-session-1",
        "Arn": "arn:aws:sts::000000000000:assumed-role/dummy-ec2-app-role/dummy-session-1"
    }
}

[スクリーンショット: 04_assume-role.png]

Expiration の行が見える状態で撮ります。「期限が入っている」ことが、この記事の後半の全部です。

返ってきた4つを1つずつ見ます。

項目何か注目点
AccessKeyId鍵の名札ASIA(本物)や LSIA(LocalStack)で始まる。恒久キーの AKIA と1文字違う
SecretAccessKey鍵の中身恒久キーと同じ役割
SessionToken一時キーにだけ付く3つ目の値これが無いと使えない。恒久キーには存在しない
Expiration失効する時刻これが最大の安全性

SessionToken という3つ目の値があること自体が、「これは一時的なものだ」という印です。 環境変数も3つになります。

bash
$ export AWS_ACCESS_KEY_ID=LSIAQAAAAAAVNCBMPNSG
$ export AWS_SECRET_ACCESS_KEY=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
$ export AWS_SESSION_TOKEN=FQoGZXIvYXdzEBYaDdummydummydummydummy...

誰になっているか確かめます。

bash
$ awsl sts get-caller-identity
{
    "UserId": "AROAQAAAAAAAY6SBJHXR:dummy-session-1",
    "Account": "000000000000",
    "Arn": "arn:aws:sts::000000000000:assumed-role/dummy-ec2-app-role/dummy-session-1"
}

arn:aws:iam: ではなく arn:aws:sts: になっています。 そして末尾が assumed-role/ロール名/セッション名 です。

これは「ユーザーがロールに化けた」のではありません。 別人格として、期限付きで振る舞っています。 ログにもこのARNが残るので、「誰がやったか」は残ります(セッション名を意味のあるものにしておく理由がここです)。

期限が来るとどうなるか。 1時間後に同じコマンドを打つと、こうなります。

An error occurred (ExpiredToken) when calling the GetCallerIdentity operation:
The security token included in the request is expired.

勝手に無効になります。 これが、恒久的なアクセスキーには絶対にできないことです。

この先は、また元の端末(ルートの認証情報)に戻ります。

bash
$ unset AWS_SESSION_TOKEN
$ export AWS_ACCESS_KEY_ID=test
$ export AWS_SECRET_ACCESS_KEY=test

⑧ インスタンスプロファイル 鍵を配らずに権限を渡す

⑦で作ったロールは、まだ誰も使っていません。 EC2に持たせるには、もう1つ包みが要ります。

インスタンスプロファイルです。

なぜ包みが要るのか

EC2に直接ロールを付けられないのは、歴史的な事情です。 EC2が受け取れるのは「インスタンスプロファイル」という入れ物で、ロールはその中に1つだけ入ります。

   [ EC2インスタンス ]
          |  紐づく
   [ インスタンスプロファイル ]   <- 包み。ロールを1つだけ入れられる
          |  中身
   [ ロール dummy-ec2-app-role ]
          |  付いているポリシー
   [ dummy-s3-readonly-one-bucket ]

AWSの画面から作ると、これは自動で作られるので見えません。 CLIでやると1手多いですが、構造がそのまま見えます。

作る

bash
$ awsl iam create-instance-profile \
    --instance-profile-name dummy-ec2-app-profile
{
    "InstanceProfile": {
        "Path": "/",
        "InstanceProfileName": "dummy-ec2-app-profile",
        "InstanceProfileId": "AIPAQAAAAAAAK3M9WZQT",
        "Arn": "arn:aws:iam::000000000000:instance-profile/dummy-ec2-app-profile",
        "CreateDate": "2026-10-05T10:21:09.663000+00:00",
        "Roles": []
    }
}

Roles: [] です。空の包みができただけで、まだ何も入っていません。

bash
$ awsl iam add-role-to-instance-profile \
    --instance-profile-name dummy-ec2-app-profile \
    --role-name dummy-ec2-app-role

入ったか確かめます。

bash
$ awsl iam get-instance-profile \
    --instance-profile-name dummy-ec2-app-profile
{
    "InstanceProfile": {
        "Path": "/",
        "InstanceProfileName": "dummy-ec2-app-profile",
        "InstanceProfileId": "AIPAQAAAAAAAK3M9WZQT",
        "Arn": "arn:aws:iam::000000000000:instance-profile/dummy-ec2-app-profile",
        "CreateDate": "2026-10-05T10:21:09.663000+00:00",
        "Roles": [
            {
                "Path": "/",
                "RoleName": "dummy-ec2-app-role",
                "RoleId": "AROAQAAAAAAAY6SBJHXR",
                "Arn": "arn:aws:iam::000000000000:role/dummy-ec2-app-role",
                "AssumeRolePolicyDocument": {
                    "Version": "2012-10-17",
                    "Statement": [
                        {
                            "Sid": "OnlyEC2CanBorrowThisRole",
                            "Effect": "Allow",
                            "Principal": {"Service": "ec2.amazonaws.com"},
                            "Action": "sts:AssumeRole"
                        }
                    ]
                }
            }
        ]
    }
}

Roles に入りました。 ここまで来ると、本物のAWSではこのプロファイルをEC2に紐づけるだけです(この記事ではEC2は起動しません。課金されるからです)。

何が起きるのか(守る側の視点)

紐づけたEC2の中では、こうなります。

bash
$ # ※ 本物のEC2の中でのイメージ。この記事では実行しません
$ aws s3 ls s3://dummy-report-bucket/

アクセスキーをどこにも書いていないのに、これが通ります。

なぜか。 AWS CLIやSDKが、自動で assume-role 相当のことをやって、期限付きの鍵を取ってきているからです。 そしてその鍵は期限が来る前に自動で取り直されます。 ファイルには一度も書かれません。

では、.env にアクセスキーを書く運用は何が違うのか

私は最初、こう書いていました。

bash
$ # ⚠️ これをやっていました
$ AWS_ACCESS_KEY_ID=AKIA...
$ AWS_SECRET_ACCESS_KEY=...

動きます。 でも、守る側として見ると、違いは決定的です。

.env に恒久キーインスタンスプロファイル
期限無い。消すまでずっと有効1時間程度で切れて、自動で取り直される
どこに存在するかサーバーのファイル、自分のPC、バックアップ、たまにGitどこにも書かれない(メモリの中だけ)
漏れたと気づいたときどこにコピーが残っているか誰も把握していない。全部探して差し替えるロールを外すだけ。既に出た鍵も期限で切れる
サーバーを増やすとき同じ鍵を配る(=危険が台数分に増える)プロファイルを紐づけるだけ。鍵は増えない
誰が使ったかの記録鍵は誰でも同じ。区別できないセッション名で区別できる
持ち出し文字列なので、コピーすればどこからでも使えるその環境の外へ持ち出しても、すぐ期限切れになる

一番きついのは3行目です。 恒久キーは、漏れたときに「どこまで広がったか」が誰にも分かりません。 ファイルにコピーされ、バックアップに入り、チャットに貼られ、全部を追う手段がありません。

そして最初に私がやった「全部Allow」と組み合わさると、被害の上限はアカウント全体になります。 この2つは、別々の失敗ではなく、同じ日にセットで起きます。

それでもキーを置く必要があるとき(自分のPCから触るときなど)は、せめて置き方を変えます。 .envは暗号化してGitに置ける — SOPSとageに書いた方法が使えます。ただし、これは「置き方の改善」であって、「置かない」には勝てません。

⑨ 今日からやること(守る側のチェックリスト)

攻撃の話は一切しません。 自分の設定を、自分で点検するための項目だけを並べます。

1. ルートユーザーを日常的に使わない

②で Arn が root になっているのを見ました。 本物のAWSでは、これはアカウントを作った直後の状態です。

ルートユーザーは、権限を制限できません。 ポリシーを貼っても、ルートには効きません。

やることなぜ
作業用のユーザーを1人作って、以後そちらを使うルートには「上限」が付けられないから
ルートのアクセスキーは、作らない(あれば消す)止められない鍵を作ることになる
ルートを使うのは、ルートでしかできない操作のときだけ請求の設定、アカウントの解約など。年に数回

2. 多要素認証(MFA)を有効にする

パスワードは、本人以外にも入力できます。 MFAは「その端末を持っている」ことを追加で確かめる仕組みです。

対象優先度
ルートユーザー最優先。ここが取られたら他の全部が無意味になる
管理権限を持つユーザー次
その他のユーザーできれば全員

3. アクセスキーではなくロールを使う

⑧の表がそのまま判断基準です。

状況使うもの
EC2などAWSの中で動くプログラムインスタンスプロファイル一択。キーを置く理由が無い
AWSの外のCI(GitHub Actionsなど)OIDCで一時的な認証情報を取る仕組みがある。恒久キーを置く前に、まずそれを調べる
自分のPCから手で触る一時的な認証情報を取る仕組み(SSO/Identity Center)を優先。恒久キーは最後の手段
どうしても恒久キーが要る権限を絞る・定期的に作り直す・置き場所を暗号化する。この3つは全部やる

OIDCの考え方そのものは、OAuthはログインの仕組みではない — 認可とOIDCで書いたものと同じです。 「鍵を渡さずに、本人だと証明させる」という発想です。

4. 権限は、足りないところから足す(全部付けてから削らない)

私がやった順番は、逆でした。

順番何が起きるか
全部Allow → あとで削る削れない。 何を消すと壊れるか分からないので、誰も触らなくなる
何も無い → 足りないものだけ足すAccessDenied が出るたびに、必要な権限が1つずつ分かる

AccessDenied は、邪魔ではなく情報です。 ⑤の表で末尾を読めば、何を足せばよいかが書いてあります。

具体的な進め方はこうです。

  1. 何も付けずに動かす
  2. AccessDenied を読む。末尾が because no ... allows なら、Actionが1つ足りないだけ
  3. メッセージに出ている Action と Resource を、そのまま1行足す
  4. 1に戻る

この繰り返しで出来上がったポリシーが、そのアプリの「最小権限」です。 頭で考えるより速いです。

5. 使われていない権限を、定期的に見直す

権限は足すのは簡単で、減らすのは怖い。 だから放っておくと必ず増えます。

見るものコマンド(本物のAWSで)何が分かるか
アカウント全体の資格情報の状態aws iam generate-credential-report最後にいつ使われたか、MFAが有効かが一覧になる
ポリシーが本当に使われているかaws iam get-service-last-accessed-details許可しているのに一度も使っていないサービスが分かる
鍵の年齢aws iam list-access-keys の CreateDate何年も前の鍵が残っていないか

「一度も使われていない権限」は、削っても誰も困りません。 ここから減らすのが、いちばん安全です。

判断表(迷ったらこれ)

迷っていること選ぶほう理由
ユーザーに直接付けるか、グループかグループ人が増えても作業が増えない
s3:* にするか、必要な操作だけ書くか必要な操作だけ* はまだ知らない操作も含む
Resource: "*" にするか、ARNを書くかARNを書く範囲が事故の上限になる
Denyで止めるか、Allowを書かないか基本はAllowを書かない。絶対にダメなものだけDenyDenyは強すぎて、あとで例外が作れない
サーバーに鍵を置くか、ロールにするかロール期限が付く。置き場所が要らない
AccessDenied が出た。全権限を付けるか、調べるか調べる末尾に原因が書いてある
ルートで作業するか、ユーザーを作るかユーザーを作るルートには上限が付けられない

つまずいたところ

1. LocalStackが何でも通してしまい、AccessDenied が一度も出なかった

最初、私のcompose.yamlに ENFORCE_IAM=1 がありませんでした。 ポリシーは作れる、貼れる、list にも出る。なのに、Denyしたはずの操作が通ります。

既定のLocalStackは、IAMの判定を「やっていません」。 作ったポリシーは保存されているだけです。ENFORCE_IAM=1 を入れて docker compose down -v && docker compose up -d で作り直したら、拒否が出るようになりました。

それでも、LocalStackの判定は本物と完全に同じではありません。 通ったからといって本物でも通るとは限らないし、逆もあります。 構造を理解するための練習台として使い、本番の設定の正しさをLocalStackで判定しないでください。

2. Resource の /* を書き忘れて、30分溶かした

"Action": ["s3:GetObject"],
"Resource": "arn:aws:s3:::dummy-report-bucket"

これは通りません。 s3:GetObject の対象はバケットではなく、中のファイル1つだからです。

バケット自身を指すARNと、中身を指すARNは別物です。

書き方指すもの
arn:aws:s3:::バケット名入れ物そのもの。ListBucket はこちら
arn:aws:s3:::バケット名/*中の全ファイル。GetObject PutObject はこちら

目で見ても違いが分かりにくいので、両方書いてしまうのが早いです。

3. ポリシーのファイルを直したのに、反映されなかった

policy-readonly.json を編集して、また create-policy を打ちました。

An error occurred (EntityAlreadyExists) when calling the CreatePolicy operation:
A policy called dummy-s3-readonly-one-bucket already exists.

ポリシーは「上書き」できません。新しい版を作ります。

bash
$ awsl iam create-policy-version \
    --policy-arn arn:aws:iam::000000000000:policy/dummy-s3-readonly-one-bucket \
    --policy-document file://policy-readonly.json \
    --set-as-default

--set-as-default を忘れると、新しい版は作られるのに、効いているのは古い版のままです。 エラーは出ません。 ④で get-policy-version を打った理由がこれです。手元のファイルではなく、効いている版を読むこと。

4. Allowを足しても足しても通らなかった

⑤でわざと作った状態そのものです。 私はこれを、実験ではなく事故として最初に経験しました。

Deny はどこか1箇所にあれば勝ちます。 そしてDenyは、自分が書いたポリシーの中にあるとは限りません。

Denyがありうる場所気づき方
ユーザーに直接付いたポリシーlist-attached-user-policies
グループ経由で付いたポリシーlist-groups-for-user → グループの list-attached-group-policies
インラインポリシー(付属した名無しの紙)list-user-policies(attached が付かないほう)。見落としやすい
資源側(バケットポリシー)s3api get-bucket-policy
組織のSCP自分では見えないことがある。管理者に聞く

list-attached-user-policies と list-user-policies は別のコマンドです。 前者だけ見て「何も付いていない」と判断すると、インラインポリシーを見落とします。

5. create-access-key の SecretAccessKey を見失った

一度しか表示されません。 実験中に端末を消してしまい、もう一度取り出す方法はありませんでした(本物のAWSでも同じ)。作り直しました。

bash
$ awsl iam list-access-keys --user-name dummy-dev-taro
$ awsl iam delete-access-key --user-name dummy-dev-taro --access-key-id LKIAQAAAAAAAVNCBMPNSG

この「一度しか見られない値をどこかに保存しないといけない」構造そのものが、恒久キーの弱点です。 保存した瞬間、その保存先が新しい危険な場所になります。 ⑧のロールが「無いことが利点」なのは、この問題が最初から発生しないからです。

6. assume-role したあと、元に戻れなくなった

AWS_SESSION_TOKEN を export したまま、ルートの鍵に戻したら、こうなりました。

An error occurred (InvalidClientTokenId) when calling the GetCallerIdentity operation:
The security token included in the request is invalid.

AWS_SESSION_TOKEN が残っていると、そちらが優先されます。 unset AWS_SESSION_TOKEN が必要です。

一番安全なのは、一時的な認証情報は別の端末で使うことです。 混ぜると、いま自分が誰なのか分からなくなります。 迷ったら毎回 sts get-caller-identity を打ちます。

7. 「ポリシーを作った」だけで満足していた

create-policy が成功すると、達成感があります。 ですが AttachmentCount: 0 です。誰にも効いていません。

IAMの作業は必ず2段階です。

段階コマンドこれだけだと
紙を作るcreate-policy何も起きない
貼るattach-group-policy / attach-role-policy効く

8. ロールの信頼ポリシーを、通常のポリシーと同じものだと思っていた

ロールを作るとき、--assume-role-policy-document に、S3の権限を書いたJSONを渡してしまいました。

An error occurred (MalformedPolicyDocument) when calling the CreateRole operation:
Has prohibited field Resource

信頼ポリシーには Resource を書きません。 対象はこのロール自身だからです。

2枚の紙の役割を、もう一度だけ書きます。

紙答えている問い渡すところ
信頼ポリシー誰がこのロールを借りてよいかcreate-role の --assume-role-policy-document
通常のポリシー借りた人が何をしてよいかattach-role-policy

後片づけ

練習場を消します。ここまでやったものは全部消えます。

いま何を作ったか、先に確認しておきます。

bash
$ awsl iam list-users --query 'Users[].UserName'
$ awsl iam list-groups --query 'Groups[].GroupName'
$ awsl iam list-roles --query 'Roles[].RoleName'
$ awsl iam list-policies --scope Local --query 'Policies[].PolicyName'
["dummy-dev-taro", "dummy-viewer-hanako"]
["dummy-developers"]
["dummy-ec2-app-role"]
["dummy-s3-readonly-one-bucket", "dummy-rw-but-never-delete"]

まとめて消します。

bash
$ cd ~/awslab/iam
$ docker compose down -v
[+] Running 3/3
 ✔ Container awslab-iam         Removed
 ✔ Volume iam_localstack-data   Removed
 ✔ Network iam_default          Removed

-v が要ります。 これが無いと、作ったユーザーやポリシーがボリュームに残ります。 次回起動したときに、前回のダミーユーザーが生きています。

消えたか確かめます。

bash
$ docker volume ls | grep localstack
(何も出なければ消えています)

フォルダごと消します。

bash
$ cd ~
$ rm -rf ~/awslab/iam

最後に、環境変数を落とします。

bash
$ unset AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN AWS_DEFAULT_REGION
$ unalias awsl

test という文字列が環境変数に残っていると、次にAWSを触るときに混乱のもとになります。 端末を閉じても消えますが、明示的に落としておくほうが安全です。

課金について。 この記事でやったことはすべて自分のVMの中で完結しています。 LocalStackは本物のAWSに一切繋がっていません。課金は発生しません。 本物のAWSでIAM自体を使うぶんの料金や、S3・EC2など各サービスの課金がどういう構造なのかは、AWSの公式料金ページで必ず自分で確かめてください。 金額はここには書きません。

まとめ — 理解できたこと

  • IAMは設定画面ではなく、1つの判定エンジンだった。 答えている問いは 「この主体は、この操作を、この資源に対してやってよいか」 の1つだけ
  • ポリシーの中身は Effect / Action / Resource (+場合により Principal と Condition)で全部。 項目がどれだけ並んでいても、判定に使われているのはこれだけ
  • 判定の順番は「明示的Deny > 明示的Allow > 暗黙のDeny」で固定されている。 Allowを何枚足しても、Denyが1つあれば絶対に通らない
  • AccessDenied の末尾が、直す場所を教えている。 explicit deny in an identity-based policy と because no identity-based policy allows は原因も直し方も違う。私が最初に見たのは後者で、Allowを1つ足せば済んだ
  • 「全部Allow」は、問題を解いていない上に、被害の上限を最大にする。 しかもDenyには勝てないので、効かないことすらある
  • s3:* は「読み書き」ではない。 消す・公開範囲を変える・バージョン管理を止める・時限削除を仕込む、まで全部含む。まだ知らない操作も含む
  • arn:aws:s3:::バケット名 と arn:aws:s3:::バケット名/* は別物。 一覧と読み取りで、必要なARNが違う
  • 権限はユーザーではなくグループに付ける。 3人のうちにやれば楽で、30人になってからは直せない
  • ポリシーは「作る」と「貼る」の2段階。 AttachmentCount: 0 は、何も起きていないという意味
  • 権限は人の側だけでなく、資源の側からも出せる。 ユーザーのポリシーが空でも、バケットポリシーで読めることを実際に確かめた。点検する場所は2箇所ある
  • ロールはパスワードもアクセスキーも持たない。「無い」ことが利点。 借りると期限付きの認証情報が発行され、SessionToken という3つ目の値と Expiration が付く
  • ロールには紙が2枚要る。 「誰が借りてよいか」(信頼ポリシー)と「借りた人が何をしてよいか」。役割がまったく違い、信頼ポリシーに Resource は書けない
  • インスタンスプロファイルが「サーバーに鍵を置かない」唯一の正解。 鍵を配らずに権限が渡り、期限も自動で更新される
  • 恒久キーの最大の問題は、漏れたときに「どこまで広がったか」が誰にも分からないこと。 ファイル・バックアップ・チャットに散る。ロールなら期限で自然に切れる
  • 権限は「足りないところから足す」。 全部付けてから削るのは、怖くて誰も削らないので、実際には減らない
  • そして、AWSのアカウントを作らなくても、ここまでは全部手で確かめられた。 課金は一切発生していない

参考リンク


次に読む

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

記事
← 前の記事クラウドとは何か・責任共有モデル — 借りても責任は消えない
→ 次の記事VPCとサブネットを自分で作る — 公開と非公開の差はルート1行

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

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

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

AWS›AWS — IAM
  • Principal / Action / Resource が全部
  • ロールは鍵を配らずに権限を渡す

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

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

コメント

コメントする

目次