Adam Huang

AWS Knowledge

DONT FORGET TO REPLACE ME LATER

Blog Home Posted by on 12.15.25 in Uncategorized

Amazon ECS vs EKS

Both are container orchestration services on AWS, but they use different technologies.

Amazon ECS (Elastic Container Service)
What is it?
Key Features:
Best For:
Amazon EKS (Elastic Kubernetes Service)
What is it?
Key Features:
Best For:
Quick Comparison:
FeatureECSEKS
TechnologyAWS proprietaryOpen-source Kubernetes
ComplexitySimplerMore complex
PortabilityAWS onlyMulti-cloud
CostFree (pay resources)$0.10/hr + resources
Learning CurveEasierSteeper
EcosystemAWS servicesKubernetes ecosystem

Simple analogy: ECS is like using an iPhone (simple, integrated), EKS is like using Android (flexible, portable).

Is ECS a serverless?

Amazon ECS (Elastic Container Service) is not fully serverless, but it has a serverless option:

ECS Launch Types:
  1. EC2 Launch Type – Not serverless
    • You manage the underlying EC2 instances
    • You’re responsible for scaling, patching, and maintaining the infrastructure
  2. Fargate Launch Type – Serverless
    • AWS manages the underlying infrastructure
    • You only define CPU, memory, and deploy containers
    • No server management required
    • Pay only for resources your containers use
Comparison:

AWS Fargate Explained

AWS Fargate is a serverless compute engine for containers that works with both Amazon ECS and Amazon EKS.

Key Concepts:
What is Fargate?
How It Works:
  1. Define your container: Specify Docker image, CPU, memory requirements
  2. Deploy: Launch your container using ECS or EKS
  3. Fargate handles: Server provisioning, scaling, patching, security
  4. You focus on: Your application code and business logic
Benefits:

✅ No server management – No EC2 instances to configure or maintain
✅ Automatic scaling – Scales containers independently
✅ Improved security – Each task runs in its own isolated environment
✅ Pay per use – Billed based on vCPU and memory resources used
✅ Faster deployment – No need to wait for EC2 instances to launch

Use Cases:
Pricing Model:

Think of it as: Lambda for containers – you bring the container, AWS handles everything else.

Amazon ECS vs EKS

Both are container orchestration services on AWS, but they use different technologies.

Amazon ECS (Elastic Container Service)
What is it?
Key Features:
Best For:

Amazon EKS (Elastic Kubernetes Service)

What is it?
Key Features:
Best For:
Quick Comparison:
FeatureECSEKS
TechnologyAWS proprietaryOpen-source Kubernetes
ComplexitySimplerMore complex
PortabilityAWS onlyMulti-cloud
CostFree (pay resources)$0.10/hr + resources
Learning CurveEasierSteeper
EcosystemAWS servicesKubernetes ecosystem

Simple analogy: ECS is like using an iPhone (simple, integrated), EKS is like using Android (flexible, portable).

Use API Gateway + ECS + Fargate To Deploy API

Here’s how to deploy your containerized API:

Architecture Overview:
Client → API Gateway → VPC Link/ALB → ECS Service (Fargate) → Your Container (ECR)
Deployment Steps:
1. Push Docker Image to ECR ✅ (You’ve done this)
# Build and push to ECR
docker build -t my-api .
docker tag my-api:latest <account-id>.dkr.ecr.<region>.amazonaws.com/my-api:latest
docker push <account-id>.dkr.ecr.<region>.amazonaws.com/my-api:latest
2. Create ECS Task Definition
3. Create ECS Service
4. Integrate API Gateway

Two options:

Option A: HTTP API → ALB (Recommended)
Option B: REST API → VPC Link → NLB
Sample Architecture (Recommended):
┌─────────────┐
│ API Gateway │
│  (HTTP API) │
└──────┬──────┘
       │
       ▼
┌─────────────┐
│     ALB     │ (Application Load Balancer)
└──────┬──────┘
       │
       ▼
┌─────────────┐
│ ECS Service │
│  (Fargate)  │
│             │
│ ┌─────────┐ │
│ │Container│ │ ← Your API from ECR
│ └─────────┘ │
└─────────────┘
Why This Works Well:

✅ Scalable: Fargate auto-scales based on traffic
✅ Serverless: No server management
✅ Cost-effective: Pay only for what you use
✅ Secure: Private VPC networking
✅ Managed: API Gateway handles routing, throttling, auth

Alternative (Simpler):

If you want even simpler, skip API Gateway and expose ALB directly:

Client → ALB → ECS/Fargate → Container

Use this if you don’t need API Gateway features like:

Answer: Yes, this is a valid and common AWS architecture! 🚀

Lambda vs ECS + Fargate

Let me compare these two approaches:

AWS Lambda (Serverless Functions)

What is it?
Pros:

✅ Simplest – Just upload code, no Docker needed
✅ Auto-scales instantly (0 to thousands)
✅ Pay per request – Very cost-effective for sporadic traffic
✅ Built-in API Gateway integration
✅ No infrastructure management
✅ Free tier – 1M requests/month

Cons:

❌ 15-minute timeout limit
❌ Cold starts (100ms-1s delay)
❌ Limited resources (10GB memory max)
❌ Limited runtime support
❌ Not ideal for long-running processes

Best For:

ECS + Fargate (Containerized Applications)

What is it?
Pros:

✅ No timeout limits – Run as long as needed
✅ Any runtime/language – Full Docker flexibility
✅ More resources – Up to 16 vCPU, 120GB memory
✅ No cold starts – Always warm
✅ Better for stateful apps
✅ Full control over environment
✅ Existing Docker images work as-is

Cons:

❌ More complex – Need to manage Docker, task definitions
❌ Always running – Pay even with zero traffic (unless scaled to 0)
❌ Slower scaling than Lambda
❌ Need ALB/NLB for API exposure
❌ Higher minimum cost

Best For:

Cost Comparison Example:

Scenario: API with 1M requests/month, 1GB memory, 1s avg execution
ServiceCost Breakdown
Lambda~$20/month (pay per invocation)
ECS + Fargate~$30-50/month (always running 1 task)

For low/sporadic traffic: Lambda wins
For consistent traffic: Fargate becomes cheaper at scale

Decision Matrix:
Choose Lambda if:
├─ Execution < 15 minutes
├─ Sporadic/unpredictable traffic
├─ Simple dependencies
├─ Want zero infrastructure
└─ Cost optimization for low traffic

Choose ECS + Fargate if:
├─ Long-running processes
├─ Consistent traffic
├─ Complex Docker setup
├─ Need full OS control
├─ Cold starts are unacceptable
└─ Already have containers

For Your API:

Use Lambda if:
Use ECS + Fargate if:

Hybrid Approach:

You can also use both:

Bottom line: For a typical REST API from Docker, Lambda is simpler, but ECS + Fargate gives more control. Start with Lambda unless you have specific container requirements! 🚀