EC2 vs ECS vs EKS: the same app three ways, real monthly cost

There are three common ways to run a container on AWS: on an EC2 server you manage, on ECS with Fargate, where AWS runs the containers for you, or on EKS, managed Kubernetes. To compare them fairly, I deployed the same small Go app all three ways from the same Docker image, and priced each one for a month.

Way	What you pay for (us-east-1)	About a month	Who patches the servers
EC2	1 x t3.small, 8 GB gp3, public IPv4	$19	You
ECS on Fargate	0.25 vCPU + 0.5 GB task, public IPv4	$13	AWS
EKS	Control plane, 2 x t3.small nodes, load balancer, IPv4	$132	You (nodes) and AWS (control plane)

The app and one image for both CPUs

The app is about 45 lines of Go: a hello page, a /health endpoint and a /work endpoint that burns some CPU. The Dockerfile builds it for Intel and Graviton at once, so the same tag runs anywhere:

docker buildx build --platform linux/amd64,linux/arm64 \
  -t 123456789012.dkr.ecr.us-east-1.amazonaws.com/demo-app:v1 --push .

Build once, deploy three times. Only the platform underneath changes.

Way 1: EC2, one server running Docker

The simplest setup is a server with Docker on it. In Terraform that is a security group, an instance role that can pull from ECR, and a few lines of user data:

user_data = <<-EOT
  #!/bin/bash
  dnf install -y docker
  systemctl enable --now docker
  docker run -d --restart always -p 8080:8080 ${var.image}
EOT

Cost: t3.small at $0.0208 an hour is $15.18 a month, the 8 GB gp3 disk $0.64, and the public IPv4 address $3.65. About $19 a month.

What you still own: operating system patches, Docker updates, restarts when the server dies, disk space, and scaling. With one server there is also no redundancy: if the instance or its zone has a problem, the app is down.

EC2 is right when you have one or two apps, a tight budget, and someone who is comfortable looking after Linux.

Way 2: ECS on Fargate, no servers

With Fargate you describe a task (image, CPU, memory, ports) and a service that keeps it running. There is no server to log in to and nothing to patch:

resource "aws_ecs_task_definition" "app" {
  family                   = "demo"
  requires_compatibilities = ["FARGATE"]
  network_mode             = "awsvpc"
  cpu                      = 256 # 0.25 vCPU
  memory                   = 512 # 0.5 GB
  execution_role_arn       = aws_iam_role.execution.arn
  container_definitions    = jsonencode([{ name = "app", image = var.image, portMappings = [{ containerPort = 8080 }] }])
}

Cost: 0.25 vCPU x $0.04048 plus 0.5 GB x $0.004445 per hour is $9.01 a month, plus $3.65 for the public IP. About $13 a month, cheaper than the EC2 server because you pay for the task size, not a whole instance. On Graviton (ARM64) the task costs about 20% less again.

What you still own: the task definition, the image, and the network. AWS replaces failed tasks, and running two tasks in two zones is one number in the service.

ECS on Fargate is right for most startups: from one service up to dozens, with no Kubernetes skills needed.

Way 3: EKS, managed Kubernetes

EKS gives you a real Kubernetes cluster. The app becomes a Deployment and a Service:

apiVersion: apps/v1
kind: Deployment
metadata: { name: app }
spec:
  replicas: 2
  selector: { matchLabels: { app: demo } }
  template:
    metadata: { labels: { app: demo } }
    spec:
      containers:
        - name: app
          image: 123456789012.dkr.ecr.us-east-1.amazonaws.com/demo-app:v1
          ports: [{ containerPort: 8080 }]

Cost: the control plane is $0.10 an hour, $73 a month before any node. Two t3.small nodes add $30.37, the load balancer created by the Service about $18, and the public IPs about $11. About $132 a month. If you fall behind on upgrades, the control plane moves to extended support at $0.60 an hour, $438 a month. Check your versions with the EKS version support checker.

What you still own: cluster upgrades every year or so (how to upgrade before extended support), node groups, add-ons, and the Kubernetes knowledge to run all of it. In return you get the whole Kubernetes ecosystem: Helm charts, operators, autoscalers, and portability between clouds.

EKS is right when many teams run many services, or when you need something only Kubernetes gives you.

Effort, side by side

Item	EC2	ECS Fargate	EKS
Time to first deploy	about 3 minutes	about 2 minutes	about 20 minutes (cluster create)
Config for this app	about 80 lines of Terraform	about 105 lines of Terraform	eksctl file + about 35 lines of YAML
Patching	You, every month	Nobody	You, for nodes and add-ons
Yearly upgrades	Operating system	None	Kubernetes version, one minor at a time
Good up to	1 or 2 apps	Dozens of services	Hundreds of services

Which one should you pick?

1. One app, small budget, Linux skills in the team: EC2. Add a second server and a load balancer before you call it production.
2. A startup with a few to a few dozen services: ECS on Fargate. It is the default I recommend most often.
3. Many teams, many services, or a hard need for Kubernetes: EKS. Budget for the control plane and for the people who keep it upgraded.

Moving later is possible in every direction, because all three run the same Docker image. Starting simple costs less and rarely blocks you.

Want to see what your current setup costs, or plan a move between them? Try the AWS cost calculator, look at the Kubernetes and EKS service, or start with a Free AWS Review.

Prices are on-demand Linux prices in us-east-1 from the EC2, Fargate, EKS and VPC public IPv4 pricing pages, checked in November 2026.