LambdaとECS/Fargateを選ぶときの自分用判断メモ

  • バックエンド
  • インフラ
  • 設計

Java / Spring 系の API・バッチを対象に、分かっている条件だけで暫定判断するためのメモ。 すべての条件が揃うまで待つのではなく、「現時点ではどちら寄りか」「次に何を測れば判断が変わるか」を整理する。


30秒でわかる要点

判断の順番

  1. 制約で決まるか:15分を超える可能性、OS/Native依存、常駐必須など
  2. 実行モデルは何か:「1イベント = 1処理」か、「まとまった1 Job」か
  3. 実行密度はどの程度か:実行間隔ではなく 処理時間 ÷ 実行間隔 で見る
  4. Spring / コンテナを持つ価値があるか
  5. 既存基盤をどこまで流用できるか
  6. 最後に実測コストで確認する

覚えておく3つ

  • 頻度ではなく実行密度を見る
  • 最小サイズではなく総コストを見る(Lambdaなら Memory × Duration)
  • 関数として作れるならLambda。Springアプリとして作る意味が強いならECSを比較する

「短いほどLambda、長いほどECS」は目安にはなる。 ただし実際には、Spring、並列性、既存ECS基盤、コンテナ運用、DB接続などで逆転する。


目次

  • Part 1 判断の土台:早見表 / 「分からない」を許容する
  • Part 2 まず見る強い条件:最大処理時間 / コンテナ固有要件 / 関数かJobか
  • Part 3 実行の性質を見る:実行密度 / コールドスタート / 並列化
  • Part 4 サイズ設計:Lambdaのメモリ / Fargateのサイズ
  • Part 5 Springまわり:Springを使うか / Spring Batchを使うか
  • Part 6 運用と既存基盤:既存ECS基盤への相乗り / 構築・保守運用
  • Part 7 判断と振り返り:暫定判断の目安 / 最終判断フロー / チェックリスト / 一言まとめ / 参考

Part 1 判断の土台

1-1. 早見表

観点 Lambda寄り ECS/Fargate寄り
実行時間 数秒〜数分 数分〜長時間
最大実行時間 15分以内 15分超の可能性
実行密度 低い 高い / ほぼ常時
処理単位 1イベント = 1処理 まとまったJob
並列化 自然に増やしたい 1 Taskで直列に処理したい
Java構成 素Java / 軽量 Spring Boot / Spring Batch
DB 短時間接続 Connection Poolを維持したい
コンテナ 特に必要ない OS/Native/Sidecar等が必要
運用 AWS側へ寄せたい コンテナ/JVMまで管理する価値あり
既存基盤 新規構築 成熟したECS基盤へ相乗り可能

基本仕様の確認

  • 通常のLambda Functionsは最大15分
  • LambdaのCPUはメモリ量に比例し、1,769MBで約1 vCPU相当
  • FargateはCPU/Memoryの組み合わせを明示的に選択する

※仕様・料金は変更されるため、最終設計時はAWS公式情報を確認する。


1-2. 「分からない」を許容して判断する

設計初期では、次のような情報がまだないことが多い。

  • 実処理時間
  • コールドスタート時間
  • Lambdaの適正メモリ
  • Fargateの適正CPU/Memory
  • 将来の件数
  • 実際のCPUピーク
  • GCの挙動

この段階で無理に決めず、分かっている条件だけで暫定判定する。

判定の読み方

判定 意味
Lambdaが有力 Lambda側の理由が複数あり、ECS固有の理由が少ない
ややLambda寄り 現時点ではLambdaだが、実測次第で逆転する
ほぼ互角 / 情報不足 処理時間・サイズ・既存基盤などを測る価値が高い
ややECS寄り 現時点ではECSだが、実測次第で逆転する
ECS/Fargateが有力 ECS側の理由が複数あり、Lambda固有の理由が少ない

「情報不足」は失敗ではなく、次に測るべき項目が分かった状態と考える。


Part 2 まず見る強い条件

2-1. 最大処理時間

最大15分以内
    → Lambda / ECS 両方候補

15分を超える可能性あり
    → ECS/Fargateを強く検討

見るのは平均ではなく、最大値・異常時・データ増加時。


2-2. コンテナ固有要件

次があるなら、ECS/Fargate側の理由が強くなる。

  • OSパッケージ
  • Native library
  • Sidecar
  • 独自Runtime
  • コンテナイメージを実行単位として固定したい
  • 長時間常駐Worker

逆に、次の程度なら、「コンテナ化すること自体」に価値があるかを一度考える。

Java
Jackson
JDBC
AWS SDK
単一jar

2-3. 「関数」か「Job」か

実行時間以外でかなり使いやすい判断軸。

Lambda寄り:1イベント = 1処理

SQS 1メッセージ
↓
変換
↓
DB参照
↓
更新
↓
終了

ECS寄り:まとまった1 Job

CSV取得
↓
複数レコード
↓
状態判定
↓
複数テーブル
↓
集計
↓
後処理

Part 3 実行の性質を見る

3-1. 頻度ではなく「実行密度」を見る

「1分おきだからECS」「1日1回だからLambda」とは限らない。見るべきなのは、

実行密度 = 1回の処理時間 ÷ 実行間隔
実行間隔 処理時間 実行密度
1分 180ms 約0.3%
1分 5秒 約8%
1分 30秒 50%
1分 60秒 100%
5分 30秒 10%
5分 3分 60%

目安

処理時間 << 実行間隔
    → Lambda寄り

処理時間 ≒ 実行間隔
    → ECS Service / 常駐Workerも検討

1分間隔でもウォーム時180msなら、処理自体はほぼ何もしていない時間の方が長い。 この場合、「高頻度」という理由だけで常駐ECSにする必要性は低い。


3-2. コールドスタートは「平均」で見る

例えば次のケース。

Cold: 20秒
Warm: 180ms
1分間隔

コールドスタートの原因がDB接続やHTTP/TLS接続確立で、ウォーム時に再利用できるなら、Cold 20秒だけを理由にLambdaを避けない。

見るべきもの

  • Cold時の時間
  • Warm時の時間
  • Cold発生率
  • 実運用での平均Duration
  • コールドスタートがSLA上許容できるか

ケース別の考え方

  • バッチ:初回20秒が許容されるケースも多い
  • API:「常に数百ms以内」が必要なら、コールドスタートの影響は強く見る

3-3. 並列化しない場合

Lambdaの強みの一つは、簡単な水平スケール。しかし、次のような場合はそのメリットを使わない。

  • Task数1で十分
  • 順序依存
  • DB接続数を増やしたくない
  • 同一データを同時更新したくない

だからといってLambdaが不適切になるわけではないが、Lambdaの加点要素が1つ減ると考える。

例えば次のように処理時間が極端に短ければ、並列化不要でも、Lambdaの待機0円・運用の軽さは十分大きなメリットになる。

1分間隔
並列不要
Warm 180ms
Cold 20秒

Part 4 サイズ設計

4-1. Lambdaのサイズは「小さいほど良い」ではない

Lambdaはメモリを増やすとCPUも増える。例えば、

512MB × 10秒 = 5 GB-s
1GB   × 5秒  = 5 GB-s

なら料金はほぼ同じ。1GBにしたことで4秒まで縮めば、

1GB × 4秒 = 4 GB-s

となり、大きいLambdaの方が速くて安い。

Lambdaはメモリ使用率ではなく、Memory × Duration を見る。

Javaの実測開始候補

Java構成 まず試す候補
軽量な素Java 512MB / 1GB
JDBC・Jackson等あり 1GB / 1.5GB
CPU処理あり 1GB / 1.5GB / 1769MB
Spring 1GB / 1.5GB / 1769MB / 2GB

1,769MB付近は約1 vCPU相当なので、Javaでは比較ポイントとして分かりやすい。


4-2. Fargateも「大きくしておけば安心」ではない

Java/Springで比較しやすいサイズ例

vCPU Memory 用途イメージ
0.25 1GB 軽量Java
0.25 2GB CPUは軽いがJVMメモリは欲しい
0.5 1GB 軽量Worker
0.5 2GB 小さめSpring Bootの候補
0.5 3〜4GB メモリ寄り
1 2〜4GB CPUも必要
2 8GB 比較的大きい

見るもの

  • CPU平均だけでなくピーク
  • Memory最大値
  • GC Pause
  • 処理時間
  • 起動時間
  • OOM余裕
  • JVMのHeap / Native Memory

例えば、

1 vCPU / 4GB
CPU最大 5%
Memory最大 19%

なら、単純使用量はかなり小さい。

ただし、CPU平均だけ見て 0.25 vCPU に落とすのではなく、GCや瞬間CPUを含めて負荷試験する。


Part 5 Springまわり

5-1. Springを使うか

Springを使うこと自体がECS必須条件ではない。ただしSpringの活用度が高いほど、ECS/Fargate側の合理性は増える。

素Javaで十分なことが多い Springの価値が出る
Jackson Service / Repositoryが多い
JDBC DIを多用
AWS SDK Transaction境界が複雑
Service数個 Validation
Repository数個 設定管理が多い
単純Transaction Spring Security
既存Spring資産
Spring Batch

関数として作れるならLambda。Springアプリとして作る意味が強いならECSを比較する。


5-2. Spring Batchを使うか

Spring BootとSpring Batchは二択ではない。

Spring Boot
└─ Spring Batch

Spring Batchを使う理由は「バッチだから」ではなく、バッチ実行制御をフレームワークに任せたいから。

向いているもの

  • Chunk commit
  • Reader / Processor / Writer
  • Skip
  • Retry
  • 複数Step
  • Job状態管理
  • Restart

不要なケース

次の程度で、失敗時は最初からやり直せばよいなら、普通のSpring Boot Serviceでも十分。

データ取得
↓
Validation
↓
変換
↓
INSERT / UPDATE
↓
終了

Part 6 運用と既存基盤

6-1. 既存ECS基盤への相乗り

実案件ではここがかなり重要。次のものが既にあるなら、ECSの「構築が重い」という弱点はかなり小さくなる。

  • ECS Cluster
  • ECR
  • VPC / Subnet
  • Security Group
  • IAM
  • CI/CD
  • CloudWatch
  • NAT / VPC Endpoint
  • DB疎通実績

その場合は、次を考える。

Lambdaにすることで何が嬉しいか?

それでもLambdaにする理由 ECSへ相乗りする理由
数秒〜数十秒しか動かない Spring Boot / Spring Batch
普段ほぼ停止 まとまったJob
1イベント単位 DB Connection Pool
将来並列化したい Task数1でよい
コンテナを管理したくない コンテナ運用が組織標準
JVM/GC設計を減らしたい CI/CD・監視・SG等をそのまま流用可能
小さな機能単位でデプロイしたい

6-2. インフラ構築・保守運用

Lambda側で主に見るもの ECS/Fargate側で追加されるもの
Runtime Dockerfile
Memory Base Image
Timeout ECR
IAM Image脆弱性
Concurrency Task Definition
Event source CPU / Memory
Logs / Metrics JVM Heap / GC
VPC接続 Task停止理由
Deployment
Service / RunTask

APIならさらに、ALB / Target Group / Health Check / Auto Scaling など。

Fargateは「サーバー管理不要」ではあるが、「コンテナ管理不要」ではない。


Part 7 判断と振り返り

7-1. 情報が少ない段階の暫定判断

Lambda寄りと考えてよい(次のうち複数が当てはまる)

  • 15分以内
  • 数秒〜数分
  • 実行密度が低そう
  • 1イベント単位
  • 素Java
  • コンテナ固有要件なし
  • 運用をAWSへ寄せたい

ECS寄りと考えてよい(次のうち複数が当てはまる)

  • 15分超の可能性
  • まとまったJob
  • Spring Boot / Spring Batch
  • Connection Poolを維持したい
  • 常時Worker
  • OS / Native依存
  • 既存ECS基盤へほぼそのまま相乗り可能

まだ決めなくてよい

両方当てはまる場合は、次を測る。

  1. Warm時処理時間
  2. Cold時処理時間
  3. Cold発生率
  4. Lambda 512MB / 1GB / 1.5GB等の処理時間
  5. Fargate 0.25/2GB / 0.5/2GB等の処理時間
  6. CPU/Memoryピーク
  7. 実行密度

7-2. 最終判断フロー

15分を超える?
 ├─ Yes → ECS/Fargate
 └─ 不明 / No
      ↓
コンテナ固有要件がある?
 ├─ Yes → ECS/Fargate
 └─ 不明 / No
      ↓
1イベント = 1処理として自然に切れる?
 ├─ Yes → Lambda寄り
 ├─ No  → ECS寄り
 └─ 不明
      ↓
Spring / Spring Batchをどの程度使う?
 ├─ 本格利用 → ECS寄り
 ├─ 素Java   → Lambda寄り
 └─ 不明
      ↓
実行密度は高い?
 ├─ 高い → ECS Serviceも検討
 ├─ 低い → Lambda寄り
 └─ 不明 → 実測
      ↓
成熟した既存ECS基盤へ相乗りできる?
 ├─ Yes → ECSのハードルが下がる
 └─ No  → Lambdaの運用メリットが大きい
      ↓
最後に実測コストで確認

7-3. 自分用チェックリスト

設計時に全部埋まらなくてもよい。

項目 回答
API / Batch / Worker 不明でも可
最大処理時間
Warm時処理時間
Cold時処理時間
実行間隔
1イベント単位か
並列化したいか
Spring利用度
Spring Batch
Connection Pool維持
コンテナ固有要件
既存ECS基盤
運用をAWSに寄せたいか
Lambda候補Memory
Fargate候補CPU/Memory
次に実測する項目

7-4. 一言で覚える

Lambda

必要なときだけ短く動く「処理」に向く。 コンテナ/JVM運用をAWSへ寄せられる。

ECS/Fargate

プロセスを持つ意味がある「アプリ / Job / Worker」に向く。 SpringやConnection Pool、既存コンテナ基盤を活かしやすい。

そして最重要なのは、

頻度ではなく実行密度。最小サイズではなく総コスト。

「現時点ではどちら寄りか」を先に出し、分からない項目はあとで実測して判定を更新すればよい。


7-5. 参考(AWS公式)

料金・制限・対応Runtimeは変更されるため、実際の設計時にはAWS公式の最新情報を確認する。