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

AWSでコンテナを動かす。コンテナのブロックとクラウドの台座、選定用チェックリスト。

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

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

AWS›AWS — Containers
  • 制御面と データ面の2軸で決まる
  • タスク定義は Pod マニフェストの親戚

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

前回: Lambdaとコールドスタート — 最初の1回だけ3秒かかる

これは【深掘り】の記事です。本線の順路ではありません。 本線の コンテナは軽い仮想マシンではない — Dockerの導入 で作ったイメージを、 AWS のどこで動かすのかを、ここで掘ります。飛ばしても本線は進めます。

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

この記事には、最初に正直に書いておくことがあります。 LocalStack の無料版では、この記事の ECR・ECS・EKS はいずれも動きません(ECR は Base プラン以上)。

サービスコミュニティ版でどこまで動くか
ECR動きます。 リポジトリを作り、実際にイメージを push できます
ECSAPI の応答は返りますが、タスクは実際には走りません。 この記事ではタスク定義の登録までです
EKSほぼ動きません。 クラスタは「作ったことになる」だけで、kubectl は繋がりません

だから ECS と EKS の節の目的は「動かすこと」ではなく、 設定項目の意味を読めるようになることです。 Kubernetes 側の対応物は、既に自分の minikube / kubeadm クラスタで動かしてあります。 そこと突き合わせます。


私は Docker も Kubernetes も、自分で動かしました。

Dockerfile を書いて、レイヤーキャッシュの順番で悩んで、イメージを 1.2GB から 50MB まで削って、 Compose で複数コンテナを繋いで、Pod を作って消して、Deployment のローリング更新で 502 を出して直しました。 「コンテナとは何か」は、もう分かっています。

それなのに、AWS に持っていこうとした瞬間に、手が止まりました。


私が最初に開いたのは、AWS のコンテナ関連サービスの一覧ページです。

そこに並んでいたのが、これでした。

Amazon ECS
Amazon EKS
AWS Fargate
Amazon ECR
AWS App Runner
Amazon EC2(に自分で Docker を入れる)
AWS Lambda(コンテナイメージ)

7個ありました。 そして、どのページにも「フルマネージド」「サーバーレス」「スケーラブル」と書いてあり、 どれも同じことができるように読めました。

私が最初にやった判断は、これです。

Kubernetes を勉強したのだから、EKS でいいだろう。

これが、この記事で潰す思い込みです。


もう1つ、もっと恥ずかしい思い込みがありました。

ECS のドキュメントを読んで、「タスク定義」という見慣れない言葉が出てきたとき、私はこう思いました。

ECS は Kubernetes とは全然違う仕組みだから、ゼロから覚え直しだ。

違いました。 タスク定義の JSON を1行ずつ Pod マニフェストと並べたとき、私は自分が 同じことを別の名前で書いているだけだと気づきました。

既に Kubernetes を知っているなら、ECS で新しく覚えることは、ほとんどありません。

そして、その事実は同時に、ECS のほうが軽いという結論に繋がります。 同じことができるなら、覚える量が少ないほうが勝つからです。


さらに、私はこの記事を書く前に、実際に手を止められた場所があります。

ECR にイメージを push しようとして、こう打ちました。

bash
$ docker push 000000000000.dkr.ecr.ap-northeast-1.amazonaws.com/obmes-api:latest
denied: Your authorization token has expired. Reauthenticate and try again.

「ログインしていない」のではなく、「ログインが切れた」と言われました。 ECR のログインは、docker login を1回打てば永続する類のものではありません。 これも本文で潰します。


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

目次

この記事でわかること

  • AWS でコンテナを動かす選択肢は7個に見えて、実は「2軸 × 6通り」しかない。軸は制御面とデータ面
  • ECS のタスク定義は Kubernetes の Pod マニフェストの親戚。項目はほぼ1対1で対応する
  • ECS の「サービス」は Kubernetes の Service ではなく Deployment に相当する。この名前の衝突が最大の混乱源
  • Fargate と EC2 起動タイプの違いは「誰がサーバーを持つか」だけ。課金の単位も、できることも、そこから決まる
  • Fargate ではホストに入れない。docker exec の代わりが ECS Exec になる
  • ECR はライフサイクルポリシーを設定しないと、古いイメージが永久に溜まって課金される
  • EKS は制御面だけで固定費がかかる。ECS の制御面にその費用は無い
  • 個人開発の結論は「まず EC2 1台に docker compose」。ECS が要るのは、要求が変わったときだけ

この記事でやること

  1. 選択肢を 2軸のマトリクスに落とす。 縦に「誰がオーケストレータを動かすか」、横に「誰がサーバーを持つか」
  2. LocalStack を ECR だけで立て、リポジトリを作って実際にイメージを push する
  3. タグ付けとイメージスキャンとライフサイクルポリシーを設定する(設定しないと溜まる)
  4. ECS のタスク定義 JSON を書き、Kubernetes の Pod マニフェストと1対1で並べる
  5. クラスターとサービスを作り、ローリング更新のパラメータを Kubernetes の maxSurge / maxUnavailable と対応させる
  6. EKS を選ぶ理由と選ばない理由を表にし、判断表で締める
  7. docker compose down -v で全部消す

先に知る言葉

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

言葉意味
オーケストレータコンテナをどこに何個置くか決め、落ちたら立て直す係。Kubernetes と ECS はどちらもこれ
制御面「どこに何個置くか」を決める側。Kubernetes の control plane にあたる部分
データ面実際にコンテナが載る側。ノード・サーバーにあたる部分
ECSAWS が自前で作ったオーケストレータ。Kubernetes ではない。AWS の中だけで通じる
EKS本物の Kubernetes を AWS が管理してくれるもの。API は Kubernetes そのもの
Fargateサーバーを1台も持たずにコンテナを動かす方式。ECS でも EKS でも使える
ECRAWS のコンテナレジストリ。Docker Hub の置き換え
タスク定義「どのイメージを、どのCPU・メモリで、どんな環境変数で動かすか」を書いた設計図。Pod マニフェストの親戚
タスクタスク定義から実際に起動した動いている1個。Pod にあたる
サービス(ECS)「タスクを常に N 個保つ」係。Kubernetes の Deployment にあたる。Kubernetes の Service ではない
起動タイプそのタスクを Fargate で動かすか、EC2 で動かすかの指定
ライフサイクルポリシーECR の古いイメージを、条件で自動的に消す設定

① 選択肢は「制御面」と「データ面」の2軸で決まる

先に山場をやります。 ここが分かれば、残りは全部その帰結です。

迷う理由は、軸が見えていないから

私が7個の選択肢の前で固まったのは、7個を横一列に並べて比べようとしたからです。 横に並ぶものではありませんでした。

コンテナを動かすには、必ず2つの役割が要ります。

役割やること手元でやっていたときの正体
制御面どのコンテナを何個、どこに置くか決める。落ちたら立て直すKubernetes の control plane。Compose なら docker compose コマンド
データ面実際にコンテナのプロセスを動かす。CPU とメモリを出すKubernetes のノード。Compose なら自分の VM そのもの

AWS のサービス名は、この2つの役割のどちらかを引き受ける宣言です。

  • ECS / EKS は制御面の話
  • Fargate / EC2 はデータ面の話

だから「ECS と Fargate、どっちがいいですか」という問いは、成立していません。 「ECS で、Fargate を使う」が正解の並びです。 私はここを1週間ほど誤解していました。

2×3 のマトリクス

縦に「誰がオーケストレータを動かすか」、横に「誰がサーバーを持つか」を置きます。

制御面 \ データ面EC2(自分がサーバーを持つ)Fargate(サーバーを持たない)
ECS(AWS 製の制御面)ECS on EC2。ホストに入れる。安くできるが EC2 の面倒は自分持ちECS on Fargate。AWS でコンテナを動かす最も素直な形
EKS(本物の Kubernetes)EKS + マネージドノードグループ。一番よくある構成EKS on Fargate。制約が多い。DaemonSet が動かないなど
自前(自分でオーケストレータを動かす)EC2 に docker compose / k3s / kubeadm を自分で入れる× できない。Fargate には「自前の制御面」を載せられない

6通りです。しかも右下は存在しないので、実質5通りです。

7個のサービス名で迷っていたものが、5通りの組み合わせになりました。 この表を書いてから、私は迷わなくなりました。

App Runner と Lambda はどこに入るのか

入りません。それでいいのです。

もの何が違うか
App Runner制御面もデータ面も設定させない。「このイメージを Web で公開して」だけ言う。マトリクスの外側の、もっと上の層。ただし App Runner は現在、新規顧客の受け付けを終了しています(既存の利用者は継続利用可。新機能の予定なし)。AWS は代わりに Amazon ECS Express Mode(イメージと IAM ロール2つを渡すと、Fargate 上の ECS サービスとロードバランサーまで用意してくれる)を案内しています
Lambda(コンテナイメージ)常駐しない。リクエストが来た時だけ起きる。そもそも「常に N 個保つ」という考え方が無い

上の2つは「制御面を自分で触りたくない」人向けです。 この記事のマトリクスは「制御面を触ることにした人」の中の話だと思ってください。 Lambda 側の考え方は、本線の 待っている時間に課金されない — サーバーレスとLambda で扱っています。


② 準備 — LocalStack を ECR だけで立てる

作業場所を作ります。 最後にフォルダごと消します。

bash
$ mkdir -p ~/awslab/ecs
$ cd ~/awslab/ecs
$ nano docker-compose.yml
services:
  localstack:
    image: localstack/localstack:3
    ports:
      - "4566:4566"
    environment:
      - SERVICES=ecr,ecs
      - DEBUG=0
    volumes:
      - "./volume:/var/lib/localstack"
      - "/var/run/docker.sock:/var/run/docker.sock"

docker.sock をマウントしています。 ECR に push したイメージを LocalStack が扱うために要ります。

docker.sock を渡すのは、コンテナに「ホストの Docker を全部操作する権限」を渡すのと同じです。 学習用の VM だからやっています。 本番のサーバーで、素性の分からないイメージに対してこれをやらないでください。

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

(healthy) になるまで待ちます。 starting のまま打つと繋がりません。

CLI の設定をします。

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 で通ります。 本物の鍵を打つと、間違えて本物に向けたときに課金が発生します。 鍵の管理と権限の絞り方は、この連載の IAM の回で先に扱っています。

繋がったか確認します。

bash
$ awsl ecr describe-repositories
{
    "repositories": []
}

空の配列が返れば成功です。

Could not connect to the endpoint URL が出たら、alias を貼り忘れているか、まだ healthy になっていません。


③ ECR にイメージを push する(ここは本当に動きます)

押すものを作る

push する中身が要るので、極小のイメージを作ります。

bash
$ mkdir -p ~/awslab/ecs/app
$ cd ~/awslab/ecs/app
$ nano Dockerfile
FROM alpine:3.20
RUN echo 'obmes lab' > /message.txt
CMD ["sh", "-c", "while true; do cat /message.txt; sleep 30; done"]
bash
$ docker build -t obmes-api:0.1.0 .
$ docker images obmes-api
REPOSITORY   TAG     IMAGE ID       CREATED         SIZE
obmes-api    0.1.0   0c9a1f2e3b44   2 seconds ago   7.8MB

最初から latest を付けていないことに注目してください。 理由はすぐ下で書きます。 イメージを小さくする話は 1.2GBのイメージが50MBになる — Docker深掘り でやりました。

リポジトリを作る

ECR は「1リポジトリ = 1つのアプリ」です。 Docker Hub のように何でも入れる場所ではありません。

bash
$ cd ~/awslab/ecs
$ awsl ecr create-repository \
    --repository-name obmes-api \
    --image-tag-mutability IMMUTABLE \
    --image-scanning-configuration scanOnPush=true
{
    "repository": {
        "repositoryArn": "arn:aws:ecr:ap-northeast-1:000000000000:repository/obmes-api",
        "registryId": "000000000000",
        "repositoryName": "obmes-api",
        "repositoryUri": "000000000000.dkr.ecr.ap-northeast-1.amazonaws.com/obmes-api",
        "imageTagMutability": "IMMUTABLE",
        "imageScanningConfiguration": {
            "scanOnPush": true
        }
    }
}

2つのオプションを、最初から付けています。 順番に説明します。

IMMUTABLE — latest を本番に使わない理由

設定意味
MUTABLE(既定)同じタグに何度でも上書きできる。 1.0.0 の中身が明日には別物になりうる
IMMUTABLE一度使ったタグは二度と上書きできない。 タグと中身が一生対応する

latest が本番で危険なのは、これが理由です。

「本番で動いているのは obmes-api:latest です」
  → では、いま動いている中身はいつビルドされたものですか?
  → 分かりません。

latest は「最新」という意味ではありません。「タグを省略したときに使われる名前」というだけです。 古いイメージに latest を付けることもできます。

私は手元で、実際にこれをやりました。

bash
$ docker tag alpine:3.20 obmes-api:latest

1秒で「本番の latest」が中身の違うものになりました。 これが検知できないのが問題です。

だから、この記事では最初から 0.1.0 を付けています。 実務では 0.1.0 の代わりに Git のコミットハッシュを使うことが多いです。 「そのイメージがどのコードから作られたか」が、タグを見るだけで分かるからです。

ログインして push する

bash
$ awsl ecr get-login-password --region ap-northeast-1 \
    | docker login --username AWS --password-stdin 000000000000.dkr.ecr.ap-northeast-1.amazonaws.com
WARNING! Your password will be stored unencrypted in /home/ubuntu/.docker/config.json.
Login Succeeded

get-login-password が返すのは、パスワードではなくトークンです。 そして、このトークンには有効期限があります。 期限が切れると、こうなります。

denied: Your authorization token has expired. Reauthenticate and try again.

docker login を1回打てば永続する、という感覚が間違いでした。 CI から push するときは、毎回このコマンドをジョブの中で打ちます。 手元で打った結果は、CI には無いからです。

タグを付けて push します。

bash
$ docker tag obmes-api:0.1.0 000000000000.dkr.ecr.ap-northeast-1.amazonaws.com/obmes-api:0.1.0
$ docker push 000000000000.dkr.ecr.ap-northeast-1.amazonaws.com/obmes-api:0.1.0
The push refers to repository [000000000000.dkr.ecr.ap-northeast-1.amazonaws.com/obmes-api]
5f70bf18a086: Pushed
a1b2c3d4e5f6: Pushed
0.1.0: digest: sha256:9b1c... size: 738

本当に push できました。 ここは LocalStack のコミュニティ版で動く部分です。

入っているか確認します。

bash
$ awsl ecr list-images --repository-name obmes-api
{
    "imageIds": [
        {
            "imageDigest": "sha256:9b1c...",
            "imageTag": "0.1.0"
        }
    ]
}

[スクリーンショット: 01_ECRにpushされたイメージ.png]

IMMUTABLE が効いているか、わざと壊して確かめる

同じタグでもう一度 push してみます。

bash
$ docker push 000000000000.dkr.ecr.ap-northeast-1.amazonaws.com/obmes-api:0.1.0
tag invalid: The image tag '0.1.0' already exists in the 'obmes-api' repository
and cannot be overwritten because the repository is configured to be immutable.

拒否されました。これが欲しかった動作です。 「本番のイメージが黙って別物になる」事故が、設定1つで構造的に起きなくなります。

イメージスキャン(守る側)

scanOnPush=true にしたので、push のたびに脆弱性が検査されます。

bash
$ awsl ecr describe-image-scan-findings \
    --repository-name obmes-api --image-id imageTag=0.1.0
{
    "imageScanStatus": {
        "status": "COMPLETE"
    },
    "imageScanFindingsSummary": {
        "findingSeverityCounts": {}
    }
}

LocalStack では、中身のある検査結果は返りません。 本物では、ここに件数が並びます。

大事なのは、結果の読み方のほうです。

誤解実際
件数がゼロになるまで直すゼロにはなりません。 ベースイメージの中の、直しようがないものが常にあります
件数が多いイメージは危険件数より「実際に呼ばれている経路にあるか」が重要。使っていないライブラリの件数は影響が小さい
スキャンが通れば安全スキャンは「既知の脆弱性の一覧との照合」でしかありません。 未知のものも、自分のコードのバグも見つけません

やることは1つです。「ベースイメージを新しくして、また押す」。 スキャン結果は、それを「いつやるか」を決めるための材料です。

ライフサイクルポリシー — 設定しないと溜まって課金される

ここが、この節で一番お金に直結する話です。

ECR は保存しているイメージの容量で課金されます。 そして、CI が回るたびにイメージが1個増えます。 1日10回ビルドすれば、1年で数千個になります。

私は手元に立てたプライベートレジストリで、これをやりました。 気づいたらディスクが埋まっていました。 VM なら気づきますが、ECR は容量が無限なので、気づく機会がありません。

だからルールを先に置きます。

bash
$ cd ~/awslab/ecs
$ nano lifecycle.json
{
  "rules": [
    {
      "rulePriority": 1,
      "description": "リリース用のタグは直近30個だけ残す",
      "selection": {
        "tagStatus": "tagged",
        "tagPrefixList": ["v"],
        "countType": "imageCountMoreThan",
        "countNumber": 30
      },
      "action": {
        "type": "expire"
      }
    },
    {
      "rulePriority": 2,
      "description": "タグの無いイメージは7日で消す",
      "selection": {
        "tagStatus": "untagged",
        "countType": "sinceImagePushed",
        "countUnit": "days",
        "countNumber": 7
      },
      "action": {
        "type": "expire"
      }
    }
  ]
}
bash
$ awsl ecr put-lifecycle-policy \
    --repository-name obmes-api \
    --lifecycle-policy-text file://lifecycle.json
{
    "registryId": "000000000000",
    "repositoryName": "obmes-api",
    "lifecyclePolicyText": "{\"rules\":[{\"rulePriority\":1,..."
}

読み方の注意点を4つ書きます。

注意内容
rulePriority は小さいほうが先上のルールで消える判定が出たら、下のルールは見られません
untagged が一番溜まる同じタグを上書きすると、前の実体がタグを失って残ります。 これが無言で積もる
expire と transition2025年11月から、アーカイブへ移す(transition)も選べます。 ただしアーカイブ中のイメージは pull できず、使うには復元が要ります
消したイメージは戻らない本番で動いているタスクが参照中のイメージを消さないよう、残す数は多めに

ルールが意図どおりか、消す前に確かめられます。

bash
$ awsl ecr get-lifecycle-policy-preview --repository-name obmes-api
{
    "status": "COMPLETE",
    "previewResults": [],
    "summary": {
        "expiringImageTotalCount": 0
    }
}

expiringImageTotalCount が「今このルールを適用したら何個消えるか」です。 本番のリポジトリに新しいルールを入れる前は、必ずこれを先に見てください。


④ タスク定義は Pod の親戚だった

まず書いてみる

bash
$ cd ~/awslab/ecs
$ nano taskdef.json
{
  "family": "obmes-api",
  "networkMode": "awsvpc",
  "requiresCompatibilities": ["FARGATE"],
  "cpu": "256",
  "memory": "512",
  "executionRoleArn": "arn:aws:iam::000000000000:role/ecsTaskExecutionRole",
  "taskRoleArn": "arn:aws:iam::000000000000:role/obmesApiTaskRole",
  "containerDefinitions": [
    {
      "name": "api",
      "image": "000000000000.dkr.ecr.ap-northeast-1.amazonaws.com/obmes-api:0.1.0",
      "essential": true,
      "portMappings": [
        { "containerPort": 3000, "protocol": "tcp" }
      ],
      "environment": [
        { "name": "NODE_ENV", "value": "production" }
      ],
      "secrets": [
        { "name": "DB_PASSWORD", "valueFrom": "arn:aws:ssm:ap-northeast-1:000000000000:parameter/obmes/db_password" }
      ],
      "healthCheck": {
        "command": ["CMD-SHELL", "wget -q -O - http://localhost:3000/health || exit 1"],
        "interval": 30,
        "timeout": 5,
        "retries": 3,
        "startPeriod": 10
      },
      "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
          "awslogs-group": "/ecs/obmes-api",
          "awslogs-region": "ap-northeast-1",
          "awslogs-stream-prefix": "api"
        }
      },
      "mountPoints": [
        { "sourceVolume": "cache", "containerPath": "/var/cache/app" }
      ]
    }
  ],
  "volumes": [
    { "name": "cache" }
  ]
}
bash
$ awsl ecs register-task-definition --cli-input-json file://taskdef.json
{
    "taskDefinition": {
        "taskDefinitionArn": "arn:aws:ecs:ap-northeast-1:000000000000:task-definition/obmes-api:1",
        "family": "obmes-api",
        "revision": 1,
        "status": "ACTIVE"
    }
}

ここでエラーが返ることがあります。 LocalStack のバージョンによっては ECS の API が有効になっていません。

An error occurred (InternalFailure) when calling the RegisterTaskDefinition operation: API for service 'ecs' not yet implemented or pro feature

これが出ても、この節は進められます。 ここから先で読むのはJSON の中身であって、応答ではありません。 本物の AWS で打つ必要はありません。

revision が 1 になっていることに注目してください。 タスク定義は上書きされません。 同じ family に登録するたび :2 :3 と増え、古い版も残ります。 これは Kubernetes の Deployment のリビジョン履歴と同じ発想で、戻せるようにするためです。

bash
$ awsl ecs list-task-definitions --family-prefix obmes-api
{
    "taskDefinitionArns": [
        "arn:aws:ecs:ap-northeast-1:000000000000:task-definition/obmes-api:1"
    ]
}

Pod マニフェストと1対1で並べる

ここがこの記事の中心です。 左が ECS、右が自分が既に書いた Kubernetes です。

タスク定義の項目Pod マニフェストの項目同じか
familymetadata.name(+ Deployment 名)ほぼ同じ。ECS は「名前 + revision」で1本になる
containerDefinitionsspec.containers同じ。 配列で複数書ける
containerDefinitions[].namecontainers[].name同じ
containerDefinitions[].imagecontainers[].image同じ
cpu / memory(タスク全体)spec.containers[].resources の合計ここだけ違う。 ECS はタスク全体でも指定する
containerDefinitions[].cpu / memoryresources.limits / requests近いが、requests と limits の区別が ECS には薄い
environmentenv(value 直書き)同じ
secretsenv の valueFrom.secretKeyRef同じ発想。 値を JSON に書かず参照だけ置く
portMappingscontainers[].ports同じ
healthChecklivenessProbe / readinessProbeECS はこの2つが分かれていない
logConfiguration対応物が無い(kubectl logs は標準出力を拾うだけ)ECS は送り先を明示する
mountPoints + volumesvolumeMounts + spec.volumes完全に同じ構造。 2箇所に書くところまで同じ
essential: true対応物が無い「これが死んだらタスク全体を落とす」印
taskRoleArnserviceAccountName(+ IRSA)同じ役割。 アプリが AWS を呼ぶときの身分
executionRoleArnimagePullSecrets に近いECS 自身がイメージを取る / ログを送るための身分

この表を作ったとき、私が思ったのはこれです。

新しく覚えることが、essential と executionRoleArn の2つしかない。

Pod を書けるなら、タスク定義は書けます。 Pod 側の話は 消したPodは戻ってこない — Kubernetes深掘り に書きました。

2つのロールの違いだけは、最初に潰しておく

ここは AWS 特有で、混同すると AccessDenied の原因が分からなくなります。

ロール誰が使うか例
executionRoleArnECS のエージェント(アプリではない)ECR からイメージを取る・CloudWatch にログを出す
taskRoleArn中で動いているアプリ自身アプリが S3 に書く・SQS を読む

「イメージが取れない」は executionRole の問題、「アプリから S3 に書けない」は taskRole の問題です。 私は最初、片方に全部の権限を入れて動かし、後で「誰が何をしているか」が読めなくなりました。

networkMode: awsvpc の意味

Fargate では、これしか選べません。 そして、これが一番 Kubernetes に似ています。

モード意味
bridgeDocker の既定と同じ。 ホストのポートに割り当てる。同じポートのタスクを同居させられない
hostホストのネットワークをそのまま使う。ポート衝突が起きる
awsvpcタスクごとに VPC の IP が1本もらえる。 Pod ごとに IP がもらえるのと同じ

awsvpc にすると、セキュリティグループをタスク単位で付けられます。 サブネットとセキュリティグループの考え方は、この連載の VPC の回で扱いました。

[スクリーンショット: 02_タスク定義とPodマニフェストを並べた画面.png]


⑤ Fargate と EC2 起動タイプの違い

表で対比する

観点EC2 起動タイプFargate
サーバーの管理自分。 OS 更新・ECS エージェント・ディスク容量AWS。 そもそもサーバーが見えない
課金の単位インスタンスが立っている時間。 タスクが0個でも課金されるタスクが動いている時間。 タスクを止めれば止まる
起動の速さ速い(インスタンスが既にある場合)。無い場合は追加を待つ遅い。 毎回 AWS 側で場所を用意する
使えるリソースの幅広い。 インスタンスタイプの分だけ選べる狭い。 CPU とメモリの組み合わせが決まっている
特権的な操作できる。 特権モードやカーネルパラメータの変更できない。 制限が多い
GPU使える使えない
ホストに入るできる。 SSH して docker ps が打てるできない。 ホストが存在しない
同じホストへの詰め込みできる。 小さいタスクを大量に詰めれば安いできない。 タスクごとに独立

課金の構造だけを、はっきり書く

金額は書きません。 変わりますし、この記事では1円も使いません。 Fargate の料金ページ と ECS の料金ページ を見てください。

構造だけを書きます。ここが分かれば、どちらが高くつくかは自分で判断できます。

EC2 起動タイプ
  課金 = インスタンスが立っていた時間 × インスタンスの単価
  → ⚠️ タスクが 0 個でも、インスタンスが立っていれば課金は続く
  → ⚠️ タスクを 10 個詰めても、インスタンス代は変わらない(詰めるほど得)

Fargate
  課金 = 各タスクの (CPU × 時間 + メモリ × 時間) の合計
  → ⚠️ タスクを止めれば、その分だけ止まる
  → ⚠️ タスクを 10 個動かせば、10 個分そのままかかる(詰めても得しない)

「Fargate は高い」と言われるのは、この差のことです。 逆に「たまにしか動かない・数が少ない・夜は止める」なら、Fargate のほうが安くなります。

そして EC2 側には、この連載の EBS の回で書いた罠がそのまま残ります。 インスタンスを止めても、付いているディスクの課金は続きます。

Fargate ではホストに入れない

これが、私が実際に困った点です。

手元では、コンテナが変な挙動をしたら、こう打ちます。

bash
$ docker exec -it obmes-api sh

Fargate では、この docker コマンドを打つ場所がありません。 ホストにログインできないからです。

代わりに ECS Exec があります。

bash
$ awsl ecs execute-command \
    --cluster obmes-lab \
    --task <タスクID> \
    --container api \
    --interactive \
    --command "/bin/sh"

ただし、使えるようにするために先に3つ要ります。

要るもの理由
タスク定義 / サービスで enableExecuteCommand を有効化既定は無効です。 障害が起きてから有効にしても、動いているタスクには効きません
taskRole に SSM 関連の権限接続は SSM 経由で行われるため
イメージの中にシェルがあることscratch や distroless の最小イメージには sh がありません

3番目が一番刺さりました。 1.2GBのイメージが50MBになる — Docker深掘り で頑張ってイメージを削った結果、 中に入れるものが何も無くなっていました。

つまり、こういうトレードオフが実在します。

イメージを極限まで削る  →  安全で速いが、⚠️ 障害時に中を見られない
シェルを1個残す        →  少し大きいが、⚠️ 困ったときに入れる

私は「本番では入れないほうが安全」という原則より先に、「入れない練習」をしておくべきでした。 ログとメトリクスで分かるようにしておけば、そもそも中に入る必要がありません。


⑥ クラスターとサービス — 名前が最悪に紛らわしい

クラスターを作る

bash
$ awsl ecs create-cluster --cluster-name obmes-lab
{
    "cluster": {
        "clusterArn": "arn:aws:ecs:ap-northeast-1:000000000000:cluster/obmes-lab",
        "clusterName": "obmes-lab",
        "status": "ACTIVE",
        "registeredContainerInstancesCount": 0,
        "runningTasksCount": 0
    }
}

registeredContainerInstancesCount が 0 なのに ACTIVE です。 ECS の「クラスター」は、サーバーの集まりではなく、ただの入れ物・名前空間です。

Kubernetes のクラスタとは、ここが決定的に違います。

Kubernetes のクラスタECS のクラスター
中身control plane + ノードの実体論理的な区切りだけ
作るのに何が要るかサーバーが要る(kubeadm でやりました)何も要らない。1コマンドで空でも作れる
近い概念—Kubernetes の Namespace のほうが近い

kubeadm で3台のクラスタを組んだときの手間と比べると、拍子抜けするほど簡単です。 それは「サーバーを1台も用意していないから」です。

ここで一度、名前の話をします

この記事で最も事故りやすい場所です。 はっきり書きます。

ECS の「サービス」は、Kubernetes の Service ではありません。 ECS の「サービス」は、Kubernetes の Deployment です。

対応表にします。

ECSKubernetesやること
タスク定義Pod テンプレート(+ ラベル)設計図
タスクPod実際に動いている1個
サービスDeployment望ましい数を保つ・更新する
ターゲットグループ + ALBService(type: LoadBalancer / Ingress)アクセスを振り分ける
クラスターNamespace に近い区切り
サービスディスカバリService(ClusterIP)+ DNS名前で呼ぶ

「ECS の Service を作れば、他のコンテナから名前で呼べる」わけではありません。 それは別の機能(サービスディスカバリ)です。

私はここで、丸1日を溶かしました。 ECS のサービスを作って、 「Kubernetes と同じなら DNS 名が生えるはずだ」と思って探し続けたからです。生えていませんでした。

Kubernetes の Service 側の話は PodのIPは翌日には変わる — Kubernetes深掘り に書きました。

サービスを作る

bash
$ nano service.json
{
  "cluster": "obmes-lab",
  "serviceName": "obmes-api",
  "taskDefinition": "obmes-api:1",
  "desiredCount": 3,
  "launchType": "FARGATE",
  "enableExecuteCommand": true,
  "networkConfiguration": {
    "awsvpcConfiguration": {
      "subnets": ["subnet-11111111"],
      "securityGroups": ["sg-11111111"],
      "assignPublicIp": "DISABLED"
    }
  },
  "deploymentConfiguration": {
    "minimumHealthyPercent": 100,
    "maximumPercent": 200
  }
}
bash
$ awsl ecs create-service --cli-input-json file://service.json
{
    "service": {
        "serviceArn": "arn:aws:ecs:ap-northeast-1:000000000000:service/obmes-lab/obmes-api",
        "serviceName": "obmes-api",
        "status": "ACTIVE",
        "desiredCount": 3,
        "runningCount": 0
    }
}

runningCount は 0 のままです。 これが、この記事の冒頭で書いた「ECS は実際には走らない」ところです。 タスクは起動しません。 ここで読むのは、deploymentConfiguration の2つの数字だけです。

ローリング更新のパラメータを、Kubernetes と並べる

ECS には2つの数字しかありません。 そして、どちらも desiredCount に対する%です。

ECSKubernetes意味
minimumHealthyPercentmaxUnavailable の裏返し更新中、最低でも何%を健康に保つか
maximumPercentmaxSurge を含んだ上限更新中、最大で何%まで増やしていいか

裏返しなので、そのまま読み替えると間違えます。 具体例で書きます。

desiredCount = 4 のとき

minimumHealthyPercent = 100, maximumPercent = 200
  → 常に 4 個は健康。最大 8 個まで増やせる
  → ⚠️ 新しいのを先に立ててから、古いのを落とす(安全・一時的に倍のリソース)
  → Kubernetes で言えば maxUnavailable: 0, maxSurge: 100%

minimumHealthyPercent = 50, maximumPercent = 100
  → 2 個まで減ってよい。増やせない
  → ⚠️ 古いのを落としてから、新しいのを立てる(リソースは増えないが、一時的に能力が半分)
  → Kubernetes で言えば maxUnavailable: 50%, maxSurge: 0

minimumHealthyPercent = 100 かつ maximumPercent = 100 にすると、更新が永久に進みません。 減らせず、増やせないからです。 私は Kubernetes 側で同じ設定をして、同じように固まりました。

その話は 更新中に502が出る — Kubernetes深掘り に書いてあります。 考え方が完全に同じなので、Kubernetes で一度詰まっておくと、ECS では詰まりません。

「望ましい数を保つ」が、そもそも ECS を使う理由

ここまでの設定を全部忘れても、これだけ覚えていれば十分です。

docker compose  →  ⚠️ 落ちたら落ちたまま(restart: always でも、ホストが死んだら終わり)
ECS のサービス  →  ⚠️ 落ちたら、別の場所に立て直す

この1行のために、ここまでの複雑さを引き受けるかどうか。それが判断のすべてです。 restart: always は「プロセスが落ちたら再起動する」だけで、「ホストが死んだら別の場所に移す」はしません。


⑦ EKS を選ぶ理由と、選ばない理由

表で対比する

観点ECSEKS
学習コスト低い。 覚えるのは数個の概念だけ高い。 ただし既に Kubernetes を知っているなら 0 に近い
エコシステム狭い。 AWS のものだけ広い。 Helm・ArgoCD・Prometheus がそのまま動く
移植性無い。 タスク定義は AWS でしか通じないある。 マニフェストは他のクラウドでもオンプレでも通る
運用の重さ軽い。 バージョンアップは AWS 側で進む重い。 Kubernetes のバージョンには寿命がある
制御面の課金無い。 ECS の制御面そのものに料金は発生しないある。 クラスタ1つにつき固定の時間課金
AWS との繋がり密。 IAM・ALB・ログが素直に繋がる一手間要る。 IRSA・AWS Load Balancer Controller を自分で入れる

EKS の制御面には、動かしていなくても課金がある

構造だけ書きます。金額は EKS の料金ページ を見てください。

ECS
  制御面の料金 = 0
  払うのは、下で動いている EC2 か Fargate の分だけ

EKS
  制御面の料金 = ⚠️ クラスタが存在する時間 × 固定の単価
  + 下で動いているノード(EC2 か Fargate)の分
  → ⚠️ Pod を 0 個にしても、クラスタを消さない限り制御面の課金は続く

「練習用に EKS クラスタを1個作って、放置する」が一番危ない使い方です。 何も動かしていないのに、毎時間課金されます。

この構造は、学習用の Kubernetes を選ぶときの判断そのものです。 放っておくと1年で止まる — Kubernetes深掘り と、 本線の EKSでも消えない仕事がある — 自作クラスタとの違い で、 マネージドにしても自分に残る仕事を先に書いてあります。そちらが前提です。

「Kubernetes を勉強したから EKS」は、理由になっていない

冒頭に書いた私の思い込みが、これです。潰します。

私が考えたこと実際
Kubernetes を覚えたから、活かせる EKS がいい覚えた知識は ECS でも活きます。 ④の対応表のとおりです
ECS を覚えるのは、また新しい学習ECS で新しいのは2〜3個だけ。学習コストはほぼ差がありません
EKS のほうが本格的本格的なのは「運用の量」です。 バージョンアップとアドオンの管理が毎年来ます

逆に、EKS を選ぶ理由が明確に立つ場合もあります。

EKS を選ぶ理由中身
既に Kubernetes のマニフェストや Helm チャートの資産がある書き直す作業が丸ごと消える。これは大きい
AWS から出る可能性が現実にあるマニフェストは他所でも動く。タスク定義は動かない
Kubernetes 前提のツールを使いたいArgoCD・Istio・Operator 群。ECS には対応物が無いものが多い
チームに Kubernetes を知っている人が複数いる知識が組織の資産になっている場合

私はどれにも当てはまりませんでした。だから ECS です。 「AWS しか使わない」なら、ECS のほうが軽いです。

LocalStack では、ここで止まります

正直に書きます。

bash
$ awsl eks create-cluster \
    --name obmes-eks \
    --role-arn arn:aws:iam::000000000000:role/eksRole \
    --resources-vpc-config subnetIds=subnet-11111111
An error occurred (InternalFailure) when calling the CreateEksCluster operation:
API for service 'eks' not yet implemented or pro feature

EKS はコミュニティ版では扱えません。 そして、これでいいのです。 EKS の中身は Kubernetes そのものなので、練習は minikube でできます。 EKS 固有で学ぶべきは「AWS 側との繋ぎ方」だけで、それはクラスタを立てないと触れません。

[スクリーンショット: 03_EKSはコミュニティ版で動かない.png]


⑧ 判断表 — 結局どれを選ぶか

ここまでを1枚にします。上から順に読んで、最初に当てはまったところで止まってください。

こういう状況なら選ぶもの理由
コンテナ1個を Web で公開したいだけECS Express Mode(App Runner は新規受付を終了)クラスターもタスク定義も自分で書かない。イメージと IAM ロール2つを渡すだけ(中身は ECS + Fargate とロードバランサー)
たまにしか動かない・イベントで起きればいいLambda(コンテナイメージ)常駐しないので、待っている間は課金されない
個人開発・サービス数個・止まっても自分が直せるEC2 1台に docker compose一番安く、一番速く、一番読める。まずここです
複数サービス・AWS 中心・勝手に立て直してほしいECS + Fargateサーバーを持たずに「N 個保つ」が手に入る
タスクが多い・詰め込みたい・GPU が要るECS + EC2詰めるほど安い。特権的な操作もできる
Kubernetes の資産がある / 移植性が要るEKSマニフェストがそのまま動く。書き直しが消える
オンプレも含めて統一したいEKS もしくは自前 KubernetesAPI を揃えることに価値がある場合

正直な結論

私自身の結論を書きます。

個人開発なら、まず EC2 1台に docker compose で十分です。

理由は3つです。

  1. ECS の複雑さは「勝手に立て直す」ためのもので、その要求がまだ無い
  2. 落ちたときに自分で直せるなら、自動で直る必要が無い
  3. Compose ファイルは、後で ECS にもタスク定義にも Kubernetes にも移せる(構造がほぼ同じだから)

では、いつ ECS が要るのか。1行で言えます。

「自分が寝ている間に落ちても、勝手に入れ替わっていてほしい」と思ったとき。

そう思っていないうちに ECS を入れると、 タスク定義とサービスとロール2種類とサブネットとセキュリティグループを設定して、 手元と同じものが動くだけです。

そして、その状態が一番危険です。 複雑さは増えているのに、得たものが無いからです。


判断表のいちばん上に、AWS を使わない選択肢を 1 行足すこともできます。コンテナを 1〜2 個動かすだけなら、シンVPSのような VPS を 1 台借りて Docker を入れる構成で足りる場面があり、大容量メモリプランは 2026-11 時点で 1GB(1コア・30GB)が 1ヶ月契約 750円〜36ヶ月契約で月 451円(税込)です。無料のお試し期間は無く最低利用期間は 3ヶ月なので、まずは LocalStack で手順を固めてから借りるほうが無駄がありません。

つまずいたところ

この記事を書くまでに、実際に詰まった場所です。

  1. 「ECS と Fargate はどっちがいいか」で比較表を作ろうとした。

比較できるものではありませんでした。 ECS は制御面、Fargate はデータ面で、組み合わせるものです。 ①のマトリクスを書いて、ようやく手が動きました

  1. ECS の「サービス」を作れば DNS 名が生えると思って探し続けた。

生えません。 ECS の Service は Kubernetes の Deployment で、Kubernetes の Service ではありません。 名前の衝突に丸1日使いました。 ⑥の対応表が、その日の成果物です

  1. docker push が token has expired で落ちた。

docker login は1回打てば永続すると思っていました。 ECR のトークンには有効期限があります。 CI から push するときは、毎回ジョブの中で get-login-password を打ちます

  1. latest を本番タグにしていた。

「最新」という意味だと思っていましたが、ただの既定の名前でした。古いイメージにも付けられます。 --image-tag-mutability IMMUTABLE にして、構造的に上書きできなくしました

  1. ECR にライフサイクルポリシーを入れ忘れた。

容量が無限なので、溜まっていることに気づく機会がありません。 特に untagged(タグを上書きしたときに残る実体)が無言で積もります

  1. Fargate でコンテナの中を見ようとして、入る手段が無かった。

docker exec を打つホストが存在しません。ECS Exec が要ります。 しかも enableExecuteCommand は既定で無効で、障害が起きてから有効にしても手遅れです

  1. イメージを削りすぎて、ECS Exec で入っても sh が無かった。

最小イメージにはシェルがありません。「入れないこと」を先に設計するか、シェルを1個残すかを決めておく必要がありました

  1. executionRole と taskRole を混同した。

イメージが取れないのは前者、アプリから S3 に書けないのは後者です。 最初に両方へ広い権限を入れてしまい、後から「誰が何をしているか」が読めなくなりました


後片づけ

ここは必ずやってください。 LocalStack は課金されませんが、手元のディスクとイメージは残ります。

まず、何が残っているか見ます。

bash
$ cd ~/awslab/ecs
$ awsl ecr describe-repositories --query 'repositories[].repositoryName' --output text
$ awsl ecs list-clusters --query 'clusterArns' --output text
obmes-api
arn:aws:ecs:ap-northeast-1:000000000000:cluster/obmes-lab

ECS のサービスを消します。 --force が無いと、タスクが残っていて消せません。

bash
$ awsl ecs delete-service --cluster obmes-lab --service obmes-api --force
$ awsl ecs delete-cluster --cluster obmes-lab

タスク定義は、消す前に一度「無効化」します。

bash
$ awsl ecs deregister-task-definition --task-definition obmes-api:1

本物の AWS では、deregister しても一覧からは消えず INACTIVE になるだけです。 完全に消すには delete-task-definitions が別に要ります。 ここは S3 のバージョニングと同じで、 「消したつもりで残っている」典型です。

ECR のリポジトリを消します。 中にイメージがあると拒否されます。

bash
$ awsl ecr delete-repository --repository-name obmes-api
An error occurred (RepositoryNotEmptyException) when calling the DeleteRepository operation:
The repository with name 'obmes-api' in registry with id '000000000000' cannot be deleted
because it still contains images

中身ごと消すなら --force を付けます。

bash
$ awsl ecr delete-repository --repository-name obmes-api --force
{
    "repository": {
        "repositoryName": "obmes-api",
        "repositoryArn": "arn:aws:ecr:ap-northeast-1:000000000000:repository/obmes-api"
    }
}

LocalStack を落とします。 -v を付けます。 付けないとボリュームが残ります。

bash
$ docker compose down -v
[+] Running 2/2
 ✔ Container localstack   Removed
 ✔ Volume ecs_volume      Removed

手元に作った Docker イメージも消します。

bash
$ docker rmi obmes-api:0.1.0 obmes-api:latest
$ docker rmi 000000000000.dkr.ecr.ap-northeast-1.amazonaws.com/obmes-api:0.1.0

ECR のログイン情報も消しておきます。

bash
$ docker logout 000000000000.dkr.ecr.ap-northeast-1.amazonaws.com

最後にフォルダごと消します。

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

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

bash
$ docker ps -a --filter "name=localstack"
$ docker images | grep obmes-api
$ ls ~/awslab
CONTAINER ID   IMAGE   COMMAND   CREATED   STATUS   PORTS   NAMES

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

alias awsl はシェルを閉じれば消えます。 .bashrc に書いた場合は、そちらも消してください。


まとめ — 理解できたこと

  • AWS のコンテナ関連サービスは7個に見えるが、横に並べて比べるものではない。制御面とデータ面の2軸で決まる
  • 組み合わせは 2×3 の6通り。 そのうち「自前の制御面 × Fargate」は存在しないので、実質5通り
  • 「ECS と Fargate のどちらか」は成立しない問い。 正しくは「ECS で、Fargate を使う」
  • App Runner と Lambda はマトリクスの外。制御面を触らないと決めた人のための選択肢。App Runner は新規受付を終了しているので、これから始めるなら後継の ECS Express Mode
  • ECR の latest は「最新」ではなく「既定の名前」。古いイメージにも付けられる。IMMUTABLE で構造的に封じる
  • get-login-password が返すのは期限付きトークン。 docker login は永続しない。CI では毎回打つ
  • イメージスキャンの件数はゼロにならない。 見るべきは件数ではなく「ベースイメージをいつ更新するか」
  • ECR にライフサイクルポリシーを入れないと、容量が無限なので無言で溜まって課金される。特に untagged
  • ECS のタスク定義は Pod マニフェストの親戚。 項目はほぼ1対1。新しいのは essential と executionRoleArn くらい
  • executionRole は ECS 自身の身分、taskRole はアプリの身分。 イメージが取れないのは前者、S3 に書けないのは後者
  • ECS の「サービス」は Kubernetes の Deployment。 Kubernetes の Service ではない。 最大の混乱源
  • ECS のクラスターはサーバーの集まりではなく、ただの入れ物。Kubernetes の Namespace のほうが近い
  • minimumHealthyPercent / maximumPercent は maxUnavailable / maxSurge の言い換え。両方 100 にすると更新が止まる
  • Fargate はタスクが動いている時間、EC2 はインスタンスが立っている時間で課金される。詰め込みで得をするのは EC2 側だけ
  • Fargate ではホストに入れない。 ECS Exec が要り、既定は無効で、最小イメージにはシェルが無い
  • EKS は制御面だけで固定の時間課金がある。 ECS の制御面には無い。放置したクラスタが一番危ない
  • 「Kubernetes を覚えたから EKS」は理由にならない。 その知識は ECS でもそのまま活きる
  • EKS を選ぶ正当な理由は「資産がある」「移植性が要る」「Kubernetes 前提のツールを使う」の3つ
  • 個人開発なら、まず EC2 1台に docker compose で十分。 ECS が要るのは「寝ている間に勝手に入れ替わってほしい」と思ったとき

参考リンク


次に読む

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

記事
← 前の記事Lambdaとコールドスタート — 最初の1回だけ3秒かかる
→ 次の記事CloudWatchのメトリクスとアラーム — メモリ使用率は標準では取れない

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

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

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

コメント

コメントする

目次