お金をかけずに一式を動かす — AWS深掘りの到達作品

AWS深掘りの到達作品。パソコン上のストレージ、関数のブロックと権限を表す鍵。

VPC・EC2・S3・RDSなどを、無料枠の範囲で一式つないで動かす演習です。作ったものは最後に必ず消します。

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

【深掘り】AWS の到達作品です。 S3・Lambda・IAM を、LocalStack の中で1つの deploy.sh から立ち上げます(課金なし・アカウント不要)。

前回: SESでメールを送る — バウンスを放置すると送信が止まる

これは【深掘り】の記事です。本線の順路ではありません。 そして、これは AWS深掘りシリーズの「到達作品」の回です。 新しい知識はほとんど出てきません。 これまで別々に触ってきた S3 ・ Lambda ・ IAM を、1つの小さな構成に束ねて、実際に動かして締めます。

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

最初に正直に書いておきます。 この記事の Lambda は、LocalStack がホストの Docker に「関数用のコンテナ」をもう1つ立てて動かします。 そのため docker.sock のマウントが要ります(②で書きます)。 環境によっては、それでも Lambda が動かないことがあります。 そのときのために、④の最後で「Node.js だけで同じ挙動を再現する」逃げ道も用意しました。 LocalStack はあくまで練習台です。本物の AWS ではありません。


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

目次

これは「1つにつなぐ」回です

AWS深掘りシリーズは、ここまで部品を1つずつ触ってきました。

どれも、1つずつなら動かせました。

ですが、「部品が動く」と「部品が組み合わさって1つの作品になる」は、別のことです。

このシリーズを通してずっと言ってきたのは、 借りても責任は消えない の 「動いた、と、安全に動く、は違う」でした。

この記事で、その違いを、小さな作品の上で実際に確かめます。 静的サイトを置き、フォームを受け、保存する。それだけの構成に、IAM の最小権限を通します。


めがける作品

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

  1. 小さな静的サイト(index.html 1枚)を S3 に置く
  2. そのページのフォーム送信を受ける Lambda を作る
  3. Lambda が受け取った内容を、別の S3 バケットに保存する
  4. その Lambda を、「保存用のバケットにだけ書ける」最小権限のロールで動かす
  5. ①〜④の全部を、1つの deploy.sh から立ち上げる

全部 LocalStack の中で完結します。 本物の AWS には1度も繋ぎません。 そして、1つのスクリプトで再現できる形にします。 これが、この記事のもう1つの狙いです。

手で1回動かして終わり、にはしません。 手順を消せない形で残します。


この記事でわかること

  • 「静的サイト+関数+保存」は、AWS の最小構成の1つ。 S3 と Lambda と IAM だけで、サーバーを1台も立てずに作れる
  • 静的サイトの配信に、動くサーバーは要らない。 S3 は「ファイルを置くと、そのまま配る」。だから、公開設定を間違えると全世界に見える
  • Lambda が「動いた」と「安全に動く」の差は、ロールの1行に出る。 Resource を * にした瞬間、その関数は全バケットを触れる
  • 最小権限は「足りなくて失敗させてから、必要な分だけ足す」。 先に全部許可すると、何が本当に必要かが分からなくなる
  • 手で打った手順は再現できない。 deploy.sh に落とすと、同じ環境が何度でも立つ。これが IaC(コードで基盤を作る)の入口
  • LocalStack で動くもの・動かないものがある。 Lambda はホストの Docker を借りる。動かない場合の逃げ道まで用意しておく

この記事でやること

  1. LocalStack を ~/awslab/capstone に立て、s3 / lambda / iam / dynamodb を使える状態にする
  2. 静的サイト(index.html)を S3 に置き、静的ウェブサイトホスティングを設定して、ブラウザから見る
  3. フォームの内容を受け取って S3 に保存する Lambda を書き、create-function して invoke する
  4. Lambda を「データ用バケットにだけ書ける」最小権限のロールに付け替える
  5. ①〜④を1つの deploy.sh にまとめ、一発で全部立てる
  6. 完成の判定チェックリストを1つずつ確かめる
  7. docker compose down -v で、作ったものを全部消す

先に知る言葉

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

言葉意味
静的サイトサーバー側で何も計算しない、置いたファイルをそのまま返すだけのサイト。HTML・CSS・画像。S3 だけで配れる
静的ウェブサイトホスティングS3 に「このバケットをWebサイトとして扱い、index.html を入口にする」と設定すること。バケットに置くのと、Webサイトとして配るのは別設定
Lambda(関数)サーバーを立てずに、コードの断片だけを動かす仕組み。呼ばれたときだけ動く。詳しくは本線
関数URL(Function URL)Lambda を HTTP で直接呼べるようにする URL。https://... を叩くと関数が動く。API Gateway より手軽
ハンドラLambda が呼び出す入口の関数。ファイル名.関数名(index.handler など)で指定する
IAMロール「人」ではなく「サービス」が名乗る権限の束。Lambda は「このロールの権限で動きます」と名乗って動く
信頼ポリシー「このロールを、誰が引き受けてよいか」を書いたもの。Lambda 用なら lambda.amazonaws.com だけ
最小権限必要なことだけを許可し、それ以外は許可しないという考え方。s3:PutObject を1つのバケットにだけ、など
deploy.sh立ち上げ手順を1本のシェルスクリプトにまとめたもの。手順を消えない形で残す=再現できる
IaCInfrastructure as Code。基盤を、画面のクリックではなくコードで作るという考え方。詳しくは本線

① 何を組むか — 構成図を先に描く

コードを書く前に、何がどこへ繋がるかを、絵にしておきます。

これを飛ばすと、あとで「このリクエストは今どこにいるのか」が分からなくなります。

全体の流れ

                     すべて LocalStack (localhost:4566) の中
   ┌───────────────────────────────────────────────────────────┐
   │                                                           │
   │   [ブラウザ] ──GET──▶ 静的サイト                          │
   │                      (S3: obmes-capstone-site)            │
   │                      index.html を配る                    │
   │       │                                                   │
   │       │ フォーム送信 (fetch POST, JSON)                   │
   │       ▼                                                   │
   │   [Lambda 関数URL] ──▶ 関数 contact                       │
   │                        event.body を受け取る              │
   │       │                                                   │
   │       │ s3:PutObject                                      │
   │       ▼                                                   │
   │   保存 (S3: obmes-capstone-data)                          │
   │       submissions/<id>.json                               │
   │                                                           │
   │   ▲ この矢印だけを許可する ── IAMロール(最小権限)          │
   │     contact は data バケットにだけ書ける。site には触れない│
   │                                                           │
   └───────────────────────────────────────────────────────────┘

   これを1本の deploy.sh が、上から順に立てる

部品は3つだけ

部品何を使うか役目
見せるS3(obmes-capstone-site)静的サイトを配る。 計算はしない
受けるLambda(contact + 関数URL)フォームの中身を受け取って、保存する
貯めるS3(obmes-capstone-data)保存先。Lambda だけがここに書く

バケットを2つに分けたのが、この構成のいちばんの工夫です。

「見せるバケット」と「貯めるバケット」を分けておくと、 ④で 「Lambda は貯めるバケットにだけ書ける」 という権限が、きれいに書けます。

もし1つのバケットに全部入れていたら、 「サイトを配るための読み取り」と「保存のための書き込み」が同じバケットに混ざり、 権限を絞りきれません。 構成図の段階で、これが決まります。

なぜ EC2 を1台も立てないのか

フォームを受けるだけなら、常時起きているサーバーは要りません。

誰かがフォームを送った、その一瞬だけ動けばいい。 それが Lambda です。 待っている時間に課金されない — サーバーレスとLambda で 書いたとおり、呼ばれていない間は、何も動いていません。

静的サイトも同じです。 HTML を返すだけなら、動く Web サーバーすら要りません。 S3 に置けば、S3 がそのまま配ってくれます。

だから、この構成には「落ちるサーバー」がありません。 起き続けるものが無いからです。


② LocalStack を立てる

ここから手を動かします。VM の中(Ubuntu Server)で打ちます。

作業場所を作る

bash
$ mkdir -p ~/awslab/capstone
$ cd ~/awslab/capstone
$ pwd

/home/<ユーザー名>/awslab/capstone と出れば、ここが作業場所です。 この記事の最後で、このフォルダごと消します。

compose ファイルを書く

bash
$ nano docker-compose.yml
services:
  localstack:
    image: localstack/localstack:3
    container_name: capstone-lab
    ports:
      - "4566:4566"
    environment:
      - SERVICES=s3,lambda,iam,dynamodb,sts,logs
      - DEBUG=0
      - LAMBDA_REMOVE_CONTAINERS=1
    volumes:
      - "./volume:/var/lib/localstack"
      - "/var/run/docker.sock:/var/run/docker.sock"
  • SERVICES に、この記事で使う s3 lambda iam dynamodb を並べています

(sts と logs は Lambda が内部で使います)

  • 最後の1行が本題です。

/var/run/docker.sock のマウントを書き忘れると、create-function は成功するのに invoke だけが失敗します。 LocalStack は Lambda を「LocalStack の中で」動かしているのではありません。 ホストの Docker に頼んで、関数用のコンテナをもう1つ立てています。 そのために、ホストの Docker ソケットを LocalStack コンテナへ渡します。 これは Lambda の回 で30分溶かした穴です。

起動する

bash
$ docker compose up -d
$ docker compose ps
NAME           IMAGE                     STATUS                    PORTS
capstone-lab   localstack/localstack:3   Up 20 seconds (healthy)   0.0.0.0:4566->4566/tcp

STATUS が (healthy) になるまで待ちます。

使えるサービスを確認する

bash
$ curl -s http://localhost:4566/_localstack/health

返ってきた JSON の中に、次の4つが available か running で入っていれば準備完了です。

"s3": "available"
"lambda": "available"
"iam": "available"
"dynamodb": "available"

[スクリーンショット: 01_localstack起動.png] docker compose ps で (healthy) が出ている画面と、curl .../health の結果で s3 lambda iam dynamodb が available になっている画面を撮ってください。

長いオプションを短くする

--endpoint-url を毎回書くのは面倒なので、エイリアスにします。

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度も繋ぎません。 IAM の考え方は AccessDeniedに全権限で答えない — AWS深掘り にあります。

alias は、このシェルを閉じると消えます。 ターミナルを開き直したら打ち直してください。


③ S3 に静的サイトを置く

まず「見せる」部分を作ります。 ここは S3 の回 の復習です。

バケットを2つ作る

bash
$ awsl s3 mb s3://obmes-capstone-site
$ awsl s3 mb s3://obmes-capstone-data
make_bucket: obmes-capstone-site
make_bucket: obmes-capstone-data
  • obmes-capstone-site … 静的サイトを置くバケット
  • obmes-capstone-data … フォームの保存先バケット(④で Lambda が書きます)

バケット名は世界で一意です。 本物の AWS では obmes-capstone-site はもう誰かが使っているかもしれません。 LocalStack の中では衝突しないので、この名前のまま進めます。

静的サイトを書く

フォームが1つだけある、素朴なページです。 送信先は、あとで deploy.sh が埋めます。

bash
$ mkdir -p site
$ nano site/index.html
<!doctype html>
<html lang="ja">
<head>
  <meta charset="utf-8">
  <title>お問い合わせ</title>
</head>
<body>
  <h1>お問い合わせ</h1>
  <form id="f">
    <input name="name" placeholder="お名前" required>
    <textarea name="message" placeholder="ご用件" required></textarea>
    <button type="submit">送信</button>
  </form>
  <p id="result"></p>
  <script>
    // __FN_URL__ は deploy.sh が実際の関数URLに書き換える
    const ENDPOINT = "__FN_URL__";
    document.getElementById("f").addEventListener("submit", async (e) => {
      e.preventDefault();
      const form = e.target;
      const body = JSON.stringify({
        name: form.name.value,
        message: form.message.value,
      });
      const res = await fetch(ENDPOINT, {
        method: "POST",
        headers: { "content-type": "application/json" },
        body,
      });
      const data = await res.json();
      document.getElementById("result").textContent =
        res.ok ? ("受け付けました: " + data.id) : ("失敗: " + data.error);
    });
  </script>
</body>
</html>

__FN_URL__ は、いまはただの文字列です。 ④で Lambda の関数URLが決まってから、⑤の deploy.sh が本物のURLに差し替えます。 手で書き換えないでください。 URLは関数を作るまで分からないからです。

このHTMLはコマンドではなく、ファイルの中身です。

バケットに置く

bash
$ awsl s3 cp site/index.html s3://obmes-capstone-site/index.html \
    --content-type text/html
upload: site/index.html to s3://obmes-capstone-site/index.html

--content-type text/html を付けています。 これが無いと、ブラウザが「これはHTMLだ」と分からず、ソースコードがそのまま表示されることがあります。

静的ウェブサイトホスティングを設定する

置いただけでは、まだ「ファイルが1個ある」だけです。 Webサイトとして配る設定を足します。

bash
$ awsl s3 website s3://obmes-capstone-site/ --index-document index.html

何も出力されません。 これで設定できています。

s3api で明示的に書くと、こうなります(同じことです)。

bash
$ awsl s3api put-bucket-website --bucket obmes-capstone-site \
    --website-configuration '{"IndexDocument":{"Suffix":"index.html"}}'
  • IndexDocument.Suffix … 入口のファイル名。 ディレクトリだけ指定されたときに、これを返す

ブラウザから見る

LocalStack でのアクセスURLは、2つの形があります。

形URL補足
オブジェクトを直接http://localhost:4566/obmes-capstone-site/index.htmlどの環境でも確実に開ける。まずこちらで確認
Webサイトとしてhttp://obmes-capstone-site.s3-website.localhost.localstack.cloud:4566/index.html を省略できる。localhost.localstack.cloud は 127.0.0.1 に向く

まず、確実に開けるほうで中身を確認します。

bash
$ curl -s http://localhost:4566/obmes-capstone-site/index.html | head -5
<!doctype html>
<html lang="ja">
<head>
  <meta charset="utf-8">
  <title>お問い合わせ</title>

HTMLがそのまま返ってくれば、置けています。

VMの中にブラウザが無い場合は、curl で中身が返ることを確認できれば十分です。 VS Code のポート転送を使っている読者は、4566 を転送すれば手元のブラウザでも開けます。

[スクリーンショット: 02_静的サイト.png] curl でHTMLが返っている画面か、ブラウザでフォームが表示されている画面を撮ってください。 まだ送信ボタンは押しても動きません(Lambda がこれからだからです)。それで構いません。

公開設定の注意 — 守る側の話

S3 の静的サイトで一番事故が多いのが、公開範囲です。

本物の AWS で「静的サイトを公開する」には、 バケットを「誰でも読める」状態にする必要があります。 このとき、設定の対象を間違えると、置いたもの全部が世界中から読めることになります。

やりたいこと正しい状態やりがちな事故
サイトのHTMLを公開site バケットのHTMLだけを読み取り可にバケット全体を公開して、置いた別ファイルまで見える
保存データは非公開data バケットは完全に非公開練習で1回公開して、そのまま本番に持っていく
アップロード用のバケット書き込みは Lambda だけ誰でも書ける状態にして、荒らされる

この記事の data バケットは、絶対に公開しません。 フォームの中身(名前・用件)が入るからです。公開してよいのは site バケットのHTMLだけです。

クラウドの情報漏洩の多くは、破られたのではなく、自分で公開してしまったものです。 「公開したのは攻撃者ではなく私」というのが、いちばん多い事故の形です。

LocalStack では、この公開設定を省いてもオブジェクトが読めてしまいます。 本物とは挙動が違う部分なので、「本番では公開範囲を明示的に絞る」ということだけ、頭に入れておいてください。


④ Lambda を作って呼ぶ

次に「受ける」部分です。 Lambda の回 の復習に、 「S3 に保存する」を足します。

まずは仮のロールで動かす

⑤で最小権限に絞りますが、まずは動かすことを優先します。 最初から権限を絞ると、「動かないのが権限のせいか、コードのせいか」が分からなくなるからです。

信頼ポリシー(誰がこのロールを引き受けてよいか)を書きます。

bash
$ mkdir -p fn
$ nano trust.json
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": { "Service": "lambda.amazonaws.com" },
      "Action": "sts:AssumeRole"
    }
  ]
}

Principal が lambda.amazonaws.com なのが要点です。 「このロールを引き受けていいのは Lambda サービスだけ」という意味です。

bash
$ ROLE_ARN=$(awsl iam create-role \
    --role-name capstone-lambda-role \
    --assume-role-policy-document file://trust.json \
    --query 'Role.Arn' --output text)

$ echo "$ROLE_ARN"
arn:aws:iam::000000000000:role/capstone-lambda-role

いまはまだ、このロールに「何をしてよいか」を1つも付けていません。 引き受けてよい相手(信頼ポリシー)だけを決めた状態です。 信頼ポリシーと通常のポリシーが別物なのは、IAM の回 の山場でした。

とりあえず動かすために、いったん広めの権限を1つ付けます。

bash
$ awsl iam put-role-policy \
    --role-name capstone-lambda-role \
    --policy-name temp-allow-s3 \
    --policy-document '{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Action":"s3:*","Resource":"*"}]}'

これは「動かすための仮」です。s3:* と Resource:* を使っています。 ⑤で必ず絞ります。 このまま本番にしてはいけません。ここが、この記事の山場の伏線です。

ハンドラを書く

フォームの内容を受け取って、data バケットに保存する関数です。

bash
$ nano fn/index.mjs
import { S3Client, PutObjectCommand } from "@aws-sdk/client-s3";

// LocalStack が AWS_ENDPOINT_URL を渡してくるので、
// SDK はそれを見て LocalStack に向かって話す。本物では自然に AWS へ向かう。
const s3 = new S3Client({});
const DATA_BUCKET = process.env.DATA_BUCKET;

export const handler = async (event) => {
  // 関数URL経由だと、送信本文は event.body に文字列で入る
  let payload;
  try {
    payload = JSON.parse(event.body || "{}");
  } catch {
    return json(400, { error: "invalid json" });
  }

  // 入力は必ず検証する。長さも切る(信じない)
  const name = String(payload.name || "").slice(0, 100).trim();
  const message = String(payload.message || "").slice(0, 1000).trim();
  if (!name || !message) {
    return json(400, { error: "name and message are required" });
  }

  const id = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
  const record = { id, name, message, at: new Date().toISOString() };

  await s3.send(new PutObjectCommand({
    Bucket: DATA_BUCKET,
    Key: `submissions/${id}.json`,
    Body: JSON.stringify(record),
    ContentType: "application/json",
  }));

  return json(200, { ok: true, id });
};

function json(statusCode, obj) {
  return {
    statusCode,
    headers: {
      "content-type": "application/json",
      "access-control-allow-origin": "*",
    },
    body: JSON.stringify(obj),
  };
}

event と context のうち、ここで使うのは event です。 関数URL経由で呼ばれると、送信本文は event.body に「文字列で」入ります。 だから JSON.parse が要ります。オブジェクトではありません。

@aws-sdk/client-s3 を import していますが、node_modules を同梱していません。 Node.js 20 の Lambda ランタイムには、AWS SDK v3 が最初から入っているからです。 だから zip はハンドラ1ファイルだけで済みます。 (Lambda の回 の「レイヤー」で触れた、同梱の話の逆側です) なお本物の AWS では、nodejs20.x は2026年4月30日に廃止(deprecated)され、セキュリティ更新が止まっています。本物で新しく作るなら nodejs22.x 以降を選びます。 この記事で使う localstack/localstack:3 は nodejs22.x に対応していないため、練習では nodejs20.x のまま進めます。

入力を信じずに slice で長さを切っているのは、守りです。 ブラウザから届く値は、いくらでも細工できるという前提で書いています。

zip にして関数を作る

bash
$ cd ~/awslab/capstone/fn
$ zip -q function.zip index.mjs
$ ls -l function.zip
$ cd ~/awslab/capstone
-rw-rw-r-- 1 ubuntu ubuntu 906 Oct 16 10:14 function.zip
bash
$ awsl lambda create-function \
    --function-name contact \
    --runtime nodejs20.x \
    --handler index.handler \
    --role "$ROLE_ARN" \
    --zip-file fileb://fn/function.zip \
    --environment "Variables={DATA_BUCKET=obmes-capstone-data}" \
    --timeout 10 \
    --memory-size 128 \
    --query 'FunctionArn' --output text
arn:aws:lambda:ap-northeast-1:000000000000:function:contact
指定意味ここを間違えると
--handler index.handlerファイル名.エクスポート名最頻出のミス。 Cannot find module になる
--zip-file fileb://file:// ではなく fileb://(バイナリ)zip がテキスト扱いになって壊れる
--environmentDATA_BUCKET をハンドラに渡す未設定だと保存先が undefined になる
--roleこの関数が名乗る権限権限不足は実行時に初めて分かる(⑤の山場)
--timeout 10秒。既定は3秒既定のまま重い処理を置くと3秒で切られる

直接呼んでみる

関数URLを付ける前に、まず invoke で直接呼びます。

bash
$ awsl lambda invoke \
    --function-name contact \
    --payload '{"body":"{\"name\":\"taro\",\"message\":\"hello\"}"}' \
    --cli-binary-format raw-in-base64-out \
    out.json

$ cat out.json | python3 -m json.tool
{
    "statusCode": 200,
    "headers": {
        "content-type": "application/json",
        "access-control-allow-origin": "*"
    },
    "body": "{\"ok\":true,\"id\":\"1760608491-a1b2c3\"}"
}

--payload の中に body を入れているのは、関数URLの形に合わせるためです。 関数URLで呼ばれると event.body に文字列が入るので、直接 invoke でも同じ形にしています。

--cli-binary-format raw-in-base64-out を付けないと、--payload が base64 だと解釈されて弾かれます。 AWS CLI v2 の仕様です。

保存されたか確認する

bash
$ awsl s3api list-objects-v2 --bucket obmes-capstone-data \
    --query 'Contents[*].Key' --output text
submissions/1760608491-a1b2c3.json

中身も見ます。

bash
$ awsl s3 cp s3://obmes-capstone-data/submissions/1760608491-a1b2c3.json - 2>/dev/null
{"id":"1760608491-a1b2c3","name":"taro","message":"hello","at":"2026-10-16T01:14:51.201Z"}

フォームの内容が、JSON になって data バケットに入りました。 これで「受けて貯める」が繋がりました。

関数URLを付ける

最後に、ブラウザから叩けるURLを付けます。

bash
$ awsl lambda create-function-url-config \
    --function-name contact \
    --auth-type NONE \
    --query 'FunctionUrl' --output text
http://<英数字>.lambda-url.ap-northeast-1.localhost.localstack.cloud:4566/

--auth-type NONE は「認証なしで誰でも叩ける」という意味です。 公開フォームなので今回はこれで正しいですが、社内APIなどでは絶対に NONE にしないでください。

このURLに、curl で POST してみます。

bash
$ FN_URL=$(awsl lambda get-function-url-config --function-name contact \
    --query 'FunctionUrl' --output text)

$ curl -s -X POST "$FN_URL" \
    -H 'content-type: application/json' \
    -d '{"name":"hanako","message":"フォームからの送信テスト"}'
{"ok":true,"id":"1760608600-d4e5f6"}

{"ok":true} が返れば、ブラウザのフォームが叩くのと同じ経路が通っています。

もし Lambda が動かなかったら(正直な逃げ道)

invoke が docker.sock 関連のエラーで失敗することがあります。

原因のほとんどは、②の compose で docker.sock のマウントを書き忘れているか、 VM の中で Docker を root なしで動かしていて、ソケットの権限が無いことです。

それでも先に進めるように、「関数の中身」を Node.js だけで再現できます。 LocalStack の S3 は動くので、保存の部分は本物と同じです。

bash
$ nano local-run.mjs
import { S3Client, PutObjectCommand } from "@aws-sdk/client-s3";

// LocalStack の S3 に、CLIと同じように話す
const s3 = new S3Client({
  endpoint: "http://localhost:4566",
  region: "ap-northeast-1",
  credentials: { accessKeyId: "test", secretAccessKey: "test" },
  forcePathStyle: true,
});

// ↓ ハンドラと同じロジック(event.body を渡した想定)
const event = { body: JSON.stringify({ name: "taro", message: "local-run" }) };
const payload = JSON.parse(event.body);
const id = `${Date.now()}-local`;
await s3.send(new PutObjectCommand({
  Bucket: "obmes-capstone-data",
  Key: `submissions/${id}.json`,
  Body: JSON.stringify({ id, ...payload, at: new Date().toISOString() }),
  ContentType: "application/json",
}));
console.log("saved:", id);
bash
$ cd ~/awslab/capstone/fn
$ npm init -y >/dev/null 2>&1
$ npm install @aws-sdk/client-s3 >/dev/null 2>&1
$ node ../local-run.mjs
$ cd ~/awslab/capstone
saved: 1760608700-local

これは Lambda ではありません。 ですが、ハンドラのロジックと、S3 への保存は、本物と同じです。 LocalStack のコミュニティ版では Lambda が環境依存で動かないことがあるので、 「関数の中身が正しいこと」だけは、この形で確かめられます。

Lambda が動いた読者は、この節は飛ばして構いません。


⑤ IAMで権限を絞る

ここが、この記事で一番大事なところです。 ④で contact は動きました。ですが、いまの権限では危険です。

いまの権限を見る

bash
$ awsl iam get-role-policy \
    --role-name capstone-lambda-role \
    --policy-name temp-allow-s3 \
    --query 'PolicyDocument' --output json
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "s3:*",
            "Resource": "*"
        }
    ]
}

Action が s3:*、Resource が * です。

これは、こういう意味です。

書いてあること実際にできること
s3:*S3 に対する操作を全部(読み・書き・削除・バケット作成・バケット削除)
Resource: *どのバケットに対しても(site も data も、他人のバケットも、全部)

フォームを1つ保存するだけの関数が、site バケットのHTMLを書き換えたり、 バケットごと消したりできる状態です。

もし、このハンドラに1行でも脆弱性があったら、被害は S3 全体に及びます。 これが「動いた」と「安全に動く」の差です。

最小権限は「足りなくて失敗させてから」作る

最初に全部許可すると、「本当に必要な権限」が分かりません。 だから、逆から作ります。

  1. まず、全部の権限を消す
  2. 関数を呼んで、失敗させる
  3. 失敗のメッセージに書いてある権限だけを、1つ足す
  4. また呼んで、通るまで繰り返す

まず消します。

bash
$ awsl iam delete-role-policy \
    --role-name capstone-lambda-role \
    --policy-name temp-allow-s3

そして呼びます。

bash
$ curl -s -X POST "$FN_URL" \
    -H 'content-type: application/json' \
    -d '{"name":"test","message":"権限を消したあと"}'

本物の AWS なら、ここで AccessDenied が返ります。 メッセージは、こういう形です。

User: arn:aws:sts::000000000000:assumed-role/capstone-lambda-role/contact
is not authorized to perform: s3:PutObject
on resource: arn:aws:s3:::obmes-capstone-data/submissions/....json

このメッセージが、そのまま「必要な権限の一覧」です。

メッセージの部分読み取れること
perform: s3:PutObject必要な Action はこれ(s3:* ではない)
on resource: ...obmes-capstone-data/...必要な Resource はこのバケットのオブジェクトだけ

LocalStack のコミュニティ版は、IAM の権限を厳密には評価しません。 権限を消しても保存が成功してしまうことがあります。 これは本物との一番大きな違いなので、正直に書いておきます。 「メッセージを読んで、必要な分だけ足す」という手順そのものが、この節の学びです。 本物の AWS では、この AccessDenied を読んでポリシーを組み立てます。

必要な分だけを書く

メッセージから読み取った「必要な権限」を、そのまま JSON にします。

bash
$ nano policy.json
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "PutSubmissionsOnly",
      "Effect": "Allow",
      "Action": "s3:PutObject",
      "Resource": "arn:aws:s3:::obmes-capstone-data/submissions/*"
    }
  ]
}

仮の権限との違いを、1つずつ見てください。

仮(危険)✅ 最小権限
Actions3:*(全操作)s3:PutObject(書き込みだけ)
Resource のバケット*(全部)obmes-capstone-data だけ
Resource の範囲バケット全体submissions/ の下だけ
site バケット触れる✅ 触れない
読み取り・削除できる✅ できない(書き込みだけ)

Resource を submissions/* まで絞ったのが効いています。 この関数は、data バケットの中でも submissions/ の下にしか書けません。 もしバグで別のキーに書こうとしても、そこで止まります。

付けます。

bash
$ awsl iam put-role-policy \
    --role-name capstone-lambda-role \
    --policy-name write-data-bucket \
    --policy-document file://policy.json

確認します。

bash
$ awsl iam list-role-policies --role-name capstone-lambda-role
{
    "PolicyNames": [
        "write-data-bucket"
    ]
}

temp-allow-s3 が消え、write-data-bucket だけになっていれば成功です。

* を使ってはいけない、の本当の理由

「面倒だから s3:* にしておこう」は、なぜ危険なのでしょうか。

理由は、「いま動く」からです。 * を付けると、確かに動きます。エラーも出ません。 だから、間違いに気づけません。

そして、あとで誰かがこの関数を別の用途に使い回したとき、 s3:* のままだと、その人は「この関数は何でもできる」という前提で使います。 権限が、その関数が何をするかの説明になっていないのです。

s3:PutObject にだけ絞ったロールs3:* のロール
読んだ人が分かることこの関数は書き込むだけだ何をするか分からない
バグの被害範囲1バケットへの書き込みだけS3 全体
使い回されたとき用途が権限で分かる危険な権限が広がる

最小権限は、いま動かすためではありません。 半年後、この構成を忘れた自分や他人が触ったときに、被害を小さくするためのものです。 AccessDeniedに全権限で答えない — AWS深掘り で書いた 「AccessDenied に全権限で答えない」が、ここで効いてきます。

インラインポリシーとマネージドポリシーの違い

いま使った put-role-policy は「インラインポリシー」です。

インライン(put-role-policy)マネージド(create-policy + attach-role-policy)
どこに付くかこのロールの中だけ独立したポリシーを、複数のロールに貼れる
使い回しできないできる(同じ権限を何度も貼る)
ロールを消すと一緒に消えるポリシーは残る
向いている場面この関数専用の権限共通の権限(複数の関数で使う)

今回は「この関数だけの権限」なので、インラインで正解です。 同じ権限を10個の関数に付けるなら、マネージドにして貼り回します。 (IAM の回 で、create-policy の AttachmentCount: 0(作っただけでは効かない)を見たのはこの話です)


⑥ 全部を1スクリプトにまとめる

ここまでの手順を、1本の deploy.sh にします。

手で打った手順は、再現できません。 数日後に同じものを立てようとして、 「バケットを先に作ったか、ロールが先だったか」を思い出せなくなります。 スクリプトにすると、順番が消えない形で残ります。

deploy.sh を書く

bash
$ cd ~/awslab/capstone
$ nano deploy.sh
bash
#!/usr/bin/env bash
  set -euo pipefail

  AWSL="aws --endpoint-url=http://localhost:4566 --region ap-northeast-1"
  SITE_BUCKET="obmes-capstone-site"
  DATA_BUCKET="obmes-capstone-data"
  ROLE_NAME="capstone-lambda-role"
  FN_NAME="contact"

  echo "==> 1. バケットを作る"
  $AWSL s3 mb "s3://$SITE_BUCKET" 2>/dev/null || true
  $AWSL s3 mb "s3://$DATA_BUCKET" 2>/dev/null || true

  echo "==> 2. IAMロールを作り、最小権限を付ける"
  $AWSL iam create-role --role-name "$ROLE_NAME" \
    --assume-role-policy-document file://trust.json >/dev/null 2>&1 || true
  $AWSL iam put-role-policy --role-name "$ROLE_NAME" \
    --policy-name write-data-bucket \
    --policy-document file://policy.json
  ROLE_ARN=$($AWSL iam get-role --role-name "$ROLE_NAME" \
    --query 'Role.Arn' --output text)

  echo "==> 3. Lambda を登録する(あれば更新する)"
  ( cd fn && zip -q function.zip index.mjs )
  $AWSL lambda create-function --function-name "$FN_NAME" \
    --runtime nodejs20.x --handler index.handler \
    --role "$ROLE_ARN" --zip-file fileb://fn/function.zip \
    --environment "Variables={DATA_BUCKET=$DATA_BUCKET}" \
    --timeout 10 --memory-size 128 >/dev/null 2>&1 \
    || $AWSL lambda update-function-code --function-name "$FN_NAME" \
         --zip-file fileb://fn/function.zip >/dev/null

  echo "==> 4. 関数URLを用意する"
  $AWSL lambda create-function-url-config --function-name "$FN_NAME" \
    --auth-type NONE >/dev/null 2>&1 || true
  FN_URL=$($AWSL lambda get-function-url-config --function-name "$FN_NAME" \
    --query 'FunctionUrl' --output text)

  echo "==> 5. サイトに関数URLを埋めて配置する"
  sed "s#__FN_URL__#${FN_URL}#" site/index.html > /tmp/capstone-index.html
  $AWSL s3 cp /tmp/capstone-index.html "s3://$SITE_BUCKET/index.html" \
    --content-type text/html >/dev/null
  $AWSL s3 website "s3://$SITE_BUCKET/" --index-document index.html

  echo ""
  echo "==> 完成"
  echo "サイト : http://localhost:4566/${SITE_BUCKET}/index.html"
  echo "フォーム: ${FN_URL}"

1行ずつの意味

行何をしているかなぜこの順番か
set -euo pipefail1つでも失敗したら止まる途中で失敗したのに最後まで走ると、壊れた状態に気づけない
s3 mb ... | | trueバケット作成(あっても続行)2回目の実行で「もうある」で止まらないため
create-role ... | | trueロール作成(あっても続行)同上。何度流しても同じ状態に収束させる
put-role-policy最小権限を付ける⑤で作った policy.json をそのまま使う
create-function ... | | update-function-code無ければ作る、あれば更新2回目はコードだけ入れ替わる
sed "s#__FN_URL__#...#"HTMLの __FN_URL__ を本物のURLに差し替えるURLは関数を作るまで分からないから、最後に埋める

\| \| true と「無ければ作る、あれば更新」が、再現できるスクリプトの肝です。 何度流しても、同じ最終状態になります(冪等)。1回目でも10回目でも、結果は同じです。

一発で立てる

bash
$ chmod +x deploy.sh
$ ./deploy.sh
==> 1. バケットを作る
==> 2. IAMロールを作り、最小権限を付ける
==> 3. Lambda を登録する(あれば更新する)
==> 4. 関数URLを用意する
==> 5. サイトに関数URLを埋めて配置する

==> 完成
サイト : http://localhost:4566/obmes-capstone-site/index.html
フォーム: http://<英数字>.lambda-url.ap-northeast-1.localhost.localstack.cloud:4566/

バケット作成 → 最小権限のロール → Lambda 登録 → サイト配置まで、1コマンドで立ちました。

[スクリーンショット: 03_deploy一発.png] ./deploy.sh を実行して「完成」まで出ている画面を撮ってください。 出力の「サイト」と「フォーム」の2行が見えていれば十分です。

これが IaC の入口です

deploy.sh は、まだ素朴なシェルスクリプトです。 ですが、「基盤を、画面のクリックではなくコードで作る」という発想は、もう入っています。

このスクリプトが育っていくと、Terraform のようなツールになります。

今回の deploy.shTerraform など
立てるできるできる
冪等(何度流しても同じ)| | true で手作りした仕組みとして持っている
消す別に書く必要があるdestroy で、作ったものを逆順に消せる
変更の差分分からないplan で「何が変わるか」を先に見せる

「手で作ったものは再現できない」という失敗を、 手で作ったものは再現できない — Terraform入門 にまとめてあります。 この deploy.sh は、その手前の一歩です。 まず手で書いて、再現できることの気持ちよさを知ってから、ツールに移ると迷いません。


⑦ 完成の判定

「動いた気がする」で終わらせません。 1つずつ、コマンドで確かめます。

チェックリスト

[ ] 1. LocalStack が立っている
[ ] 2. 静的サイトが S3 から見える
[ ] 3. フォーム(関数URL)を叩くと保存される
[ ] 4. IAM が最小権限になっている
[ ] 5. deploy.sh 一発で全部立つ
[ ] 6. docker compose down -v で全部消える

1. LocalStack が立っている

bash
$ docker compose ps --format '{{.Name}} {{.Status}}'
capstone-lab Up 10 minutes (healthy)

✅ (healthy) なら合格。

2. 静的サイトが S3 から見える

bash
$ curl -s -o /dev/null -w '%{http_code}\n' \
    http://localhost:4566/obmes-capstone-site/index.html
200

✅ 200 なら、サイトが配られています。

3. フォームを叩くと保存される

bash
$ FN_URL=$(awsl lambda get-function-url-config --function-name contact \
    --query 'FunctionUrl' --output text)

$ BEFORE=$(awsl s3api list-objects-v2 --bucket obmes-capstone-data \
    --query 'length(Contents)' --output text)

$ curl -s -X POST "$FN_URL" -H 'content-type: application/json' \
    -d '{"name":"判定","message":"完成チェック"}' >/dev/null

$ AFTER=$(awsl s3api list-objects-v2 --bucket obmes-capstone-data \
    --query 'length(Contents)' --output text)

$ echo "before=$BEFORE after=$AFTER"
before=2 after=3

✅ 保存件数が1つ増えていれば、経路がつながっています。

Lambda が動かなかった読者は、④の local-run.mjs で保存件数が増えることを確認してください。 「受けて貯める」のロジックが正しいことは、そちらで担保できます。

4. IAM が最小権限になっている

bash
$ awsl iam get-role-policy \
    --role-name capstone-lambda-role \
    --policy-name write-data-bucket \
    --query 'PolicyDocument.Statement[0].[Action,Resource]' --output text
s3:PutObject    arn:aws:s3:::obmes-capstone-data/submissions/*

✅ s3:PutObject と、data バケットの submissions/ だけになっていれば合格。 s3:* や Resource: * が残っていたら、⑤に戻ってください。

5. deploy.sh 一発で全部立つ

いったん Lambda とロールを消して、スクリプトだけで戻ることを確かめます。

bash
$ awsl lambda delete-function --function-name contact
$ awsl iam delete-role-policy --role-name capstone-lambda-role --policy-name write-data-bucket
$ awsl iam delete-role --role-name capstone-lambda-role

$ ./deploy.sh

deploy.sh だけで「完成」まで戻れば、この構成は再現できる、ということです。 手順が、あなたの記憶ではなく、ファイルに残っています。

6. 後片づけできる

これは次の節でやります。消せることも、完成の条件です。


つまずいたところ

1. フォームを送ると event.body が undefined だった

関数URL経由の event は、{ body: "文字列" } の形です。 最初、event.name を直接読もうとして undefined になりました。 JSON.parse(event.body) を通して初めて name が取れます。 invoke で直接テストするときも、--payload '{"body":"..."}' の形に合わせないと再現しません。

2. create-function は通るのに invoke で落ちた

②の compose で docker.sock のマウントを書き忘れていました。 LocalStack の Lambda は、ホストの Docker に関数用コンテナを頼みます。 ソケットを渡していないと、作成は成功して、実行だけが失敗します。 これは Lambda の回 と同じ穴でした。

3. HTMLがブラウザでソースコードのまま表示された

s3 cp に --content-type text/html を付け忘れていました。 S3 は「これが何のファイルか」を Content-Type で持ちます。 付けないと application/octet-stream 扱いになり、ブラウザがHTMLとして描画しません。

4. s3:* のまま「動いたからいい」と思った

これが一番危ない「つまずき」でした。 動いてしまうので、間違いに見えないのです。 ⑤で権限を消して、必要な分だけ足すという順番にして初めて、 「この関数に本当に必要なのは s3:PutObject だけだった」と分かりました。

5. LocalStack で権限を消しても保存できてしまった

コミュニティ版の IAM は、権限を厳密には評価しません。 「権限を消したのに curl が成功する」ので、最初は「消せていないのか?」と焦りました。 これは LocalStack の仕様です。 本物の AWS なら AccessDenied が返ります。 LocalStack は「コマンドの形」を練習する場で、「権限の判定」までは本物と同じにはなりません。

6. deploy.sh を2回流したら「もうある」で止まった

set -e を付けていたので、s3 mb(既にある)で即座に止まりました。 || true を付けて「あっても続行」にしたら、何度でも流せるようになりました。 これが冪等(何度やっても同じ状態)の作り方です。

7. __FN_URL__ が置き換わらず、フォームが動かなかった

sed の区切り文字を / にしていて、URLの / とぶつかっていました。 URLには / が入るので、sed "s/.../.../" だと壊れます。 区切りを # にして sed "s#__FN_URL__#$FN_URL#" にしたら通りました。


後片づけ

これを必ずやってください。 練習は、消すところまでが1セットです。

コンテナとデータを消す

bash
$ cd ~/awslab/capstone
$ docker compose down -v

-v を付けます。 ②の compose で volume: を作ったので、 -v が無いとデータ(バケットの中身・関数)がボリュームに残ります。

bash
$ docker compose ps

何も出なければ、コンテナは消えています。

作業フォルダごと消す

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

rm -rf は戻せません。 ~/awslab/capstone を消すことを確認してから打ってください。

本物では、消したつもりが残る

今回は LocalStack なので、down -v で本当に全部消えます。 本物の AWS はそうではありません。

  • S3 バケットは、中身が空でないと削除できません(オブジェクトを先に消す)
  • バージョニングを有効にしていると、削除しても「削除マーカー」が残ります

(S3 の回 で見た話です)

  • IAM ロールは、付いているポリシーを外してからでないと消せません

本物で「消したはずが課金が続く」のは、この消し残しが原因です。 LocalStack で消す順番を練習しておくと、本物でも消し残しが減ります。


まとめ — 理解できたこと

  • AWS の最小構成の1つは「S3(見せる)+ Lambda(受ける)+ S3(貯める)」だった。 サーバーは1台も要らなかった
  • 静的サイトは、動くサーバーなしで配れる。 S3 に置いて、静的ウェブサイトホスティングを設定するだけ
  • Content-Type を付け忘れると、HTMLがソースのまま表示される。 S3 はファイルの種類を Content-Type で持っている
  • 関数URL経由の入力は event.body に文字列で来る。 JSON.parse を通す。オブジェクトではない
  • Lambda のロールは、最初は仮でいい。まず動かし、あとで絞る。 先に絞ると、動かない原因が権限かコードか分からなくなる
  • 最小権限は「全部消して、失敗のメッセージが求める分だけ足す」。 AccessDenied は、そのまま必要な権限の一覧
  • s3:* と Resource: * は「いま動く」から危ない。 動くので間違いに気づけず、被害が S3 全体に広がる
  • Resource は、バケットの中のキーの範囲まで絞れる。 data/submissions/* だけ、のように
  • 権限は、その関数が何をするかの説明になる。 絞ってあれば、読んだ人が用途を理解できる
  • インラインとマネージドは使い分ける。 この関数専用ならインライン、使い回すならマネージド
  • 手で打った手順は再現できない。deploy.sh に落とすと消えない。 これが IaC の入口
  • || true と「無ければ作る、あれば更新」で、何度流しても同じ状態にできる(冪等)
  • 完成は、コマンドで1つずつ判定する。 「動いた気がする」で終わらせない
  • LocalStack はあくまで練習台。 Lambda は環境依存で動かないことがあり、IAM の判定も本物とは違う。本物に出すときは、まず予算アラートから

このシリーズを通して、一度も AWS アカウントを作りませんでした。 それでも、S3 のキー、Lambda のハンドラ、IAM の最小権限を、 1つの作品の上で、自分の手で組み合わせられました。

本当にアカウントを作るときは、サービスを作る前に、上限を作ってください。 やり方は クラウド料金は止め忘れで膨らむ — 先に上限を作る にあります。 順番を変えないでください。 これが、AWS深掘りシリーズを終えての、いちばんの約束です。


参考リンク


この段階の確認

【深掘り】AWS は、ここで終わりです。 次に進む前に、答えを見ずに試してください。

読み終えた直後は、たいてい「分かった気」になっています。 手が動くかどうかは別です。

説明できますか

  1. 責任共有モデルで、自分の責任はどこからどこまでか
  2. EC2を消したのに課金が続くのはなぜか
  3. S3にフォルダは存在しない。 では何があるのか

手が動きますか

  • VPCとサブネットを自分で作り、公開と非公開の差がルート1行であることを確かめる
  • IAMポリシーを読み、AccessDenied に全権限で答えない
  • 使い終わったリソースを全部消して、課金が止まったことを確認する

1つでも詰まったら、飛ばした回があります。 そこへ戻ってください。戻るのは後退ではありません。 戻り先の目安: クラウドとは何かの回 / VPCの回 / IAMの回 / EBSの回

全部答えられたなら、次の段階へ進んでください。


次に読む

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

記事
← 前の記事SESでメールを送る — バウンスを放置すると送信が止まる
→ 次の記事守る側の考え方の土台(CIA・リスク・多層防御) — 完全な安全は買えない

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

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

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

コメント

コメントする

目次