AWS ECS Fargate: What It Is, How It Works, What It Costs

ECS vs Fargate — not the same thing

ECS is the control plane. Fargate is the data plane. You need both to run containers without EC2.

Most tutorials use the terms interchangeably. They aren't the same. ECS handles orchestration — it schedules tasks, manages service definitions, handles health checks, rolling deployments, and service discovery. Fargate handles compute — it provides the CPU and memory for your containers to run on, managed by AWS.

How ECS Fargate works

Four concepts cover 90% of what you need: clusters, task definitions, services, and tasks.

You don't need to understand all of ECS to get started. These four concepts map to how you think about running applications.

Fargate pricing — real numbers

Fargate charges per vCPU-hour and per GB-hour. The ECS control plane is free. You pay only for running containers.

Source: aws.amazon.com/fargate/pricing — verified June 2026, us-east-1.

What environments actually cost

“Scheduled” = running Mon–Fri 8am–8pm only (60 hrs/week vs 168 hrs/week). Nights, weekends, and holidays stopped.

Terraform module — ready to use

The community standard is terraform-aws-modules/ecs/aws by Anton Babenko — 671 stars, last release March 2026.

Don't write ECS Terraform from scratch. This module handles cluster configuration, capacity providers, service definitions, and container specs in a consistent, maintained interface. Below is a production-ready starting point for a Fargate cluster with one service.

module "ecs_cluster" {
  source  = "terraform-aws-modules/ecs/aws"
  version = "~> 7.5"

  cluster_name = "my-app-${var.environment}"

  # Fargate + Fargate Spot capacity providers
  cluster_capacity_providers = ["FARGATE", "FARGATE_SPOT"]

  default_capacity_provider_strategy = {
    FARGATE = {
      weight = 50
      base   = 1   # min 1 task on On-Demand for stability
    }
    FARGATE_SPOT = {
      weight = 50
    }
  }

  # Define your services inline
  services = {
    api = {
      cpu    = 512   # 0.5 vCPU
      memory = 1024  # 1 GB

      container_definitions = {
        api = {
          essential = true
          image     = "${var.ecr_repo_url}:${var.image_tag}"
          cpu       = 512
          memory    = 1024

          port_mappings = [{
            name          = "http"
            containerPort = 8080
            protocol      = "tcp"
          }]

          environment = [
            { name = "PORT",        value = "8080" },
            { name = "ENVIRONMENT", value = var.environment },
          ]

          log_configuration = {
            logDriver = "awslogs"
            options = {
              awslogs-group         = "/ecs/${var.environment}/api"
              awslogs-region        = var.aws_region
              awslogs-stream-prefix = "api"
              mode                  = "non-blocking"
              max-buffer-size       = "4m"
            }
          }
        }
      }

      subnet_ids         = var.private_subnet_ids
      security_group_ids = [aws_security_group.ecs_tasks.id]
    }
  }

  tags = {
    Environment = var.environment
    ManagedBy   = "terraform"
  }
}

# To stop all services in an environment (e.g. at night):
# aws ecs update-service --cluster my-app-dev --service api --desired-count 0

The last comment shows how to stop a service manually. At 1–3 environments, this is fine. At 10+ environments, you're running this command 30–60 times per day (start in the morning, stop at night, per service, per environment). That's when teams build scheduling automation — or use a tool that does it.

ECS Fargate vs EKS

ECS: $0 control plane, $0 idle, ~0.1 FTE ops overhead. EKS: $73/mo per cluster, can't reach $0 when idle, ~0.5–2 FTE (full-time engineer equivalent) ops overhead.

The choice between ECS and EKS is not primarily about cost — it's about operational model. EKS buys you the Kubernetes ecosystem (operators, Helm charts, multi-cloud). ECS buys you simplicity and full AWS integration without owning a control plane.

What breaks at 10+ environments

Terraform handles provisioning at 10+ environments. What breaks is operations — the layer between your IaC and your developers.

Most teams hit this wall around their 10th environment. The Terraform is clean. The services are running. But the operational overhead is silently accumulating.

FAQ