Retrospective: We Saved 40% on AWS Costs by Ditching EC2 for AWS Fargate 2026 and Karpenter 1.1

import yaml
import sys
import logging
from typing import Dict, List, Any
from kubernetes import client, config
from kubernetes.client.rest import ApiException

# Configure logging for audit trails
logging.basicConfig(
    level=logging.INFO,
    format=\"%(asctime)s - %(levelname)s - %(message)s\"
)
logger = logging.getLogger(__name__)

def load_kube_config() -> None:
    \"\"\"Load local kubeconfig or in-cluster config for EKS access.\"\"\"
    try:
        config.load_kube_config()
        logger.info(\"Loaded local kubeconfig\")
    except Exception as e:
        logger.warning(f\"Failed to load kubeconfig: {e}, trying in-cluster config\")
        try:
            config.load_incluster_config()
            logger.info(\"Loaded in-cluster EKS config\")
        except Exception as e:
            logger.error(f\"Failed to load any k8s config: {e}\")
            sys.exit(1)

def migrate_pod_to_fargate(pod_spec: Dict[str, Any]) -> Dict[str, Any]:
    \"\"\"
    Modify pod spec to use Fargate capacity instead of EC2 node selectors.
    Removes EC2-specific node selectors, adds Fargate profile labels.
    \"\"\"
    # Remove EC2 node selector if present
    if \"nodeSelector\" in pod_spec:
        node_selector = pod_spec[\"nodeSelector\"]
        if \"kubernetes.io/instance-type\" in node_selector or \"topology.kubernetes.io/zone\" in node_selector:
            logger.info(f\"Removing EC2 node selectors: {node_selector}\")
            del pod_spec[\"nodeSelector\"]

    # Add Fargate-specific labels to pod metadata
    if \"metadata\" not in pod_spec:
        pod_spec[\"metadata\"] = {}
    if \"labels\" not in pod_spec[\"metadata\"]:
        pod_spec[\"metadata\"][\"labels\"] = {}

    pod_spec[\"metadata\"][\"labels\"][\"compute-type\"] = \"fargate\"
    pod_spec[\"metadata\"][\"labels\"][\"karpenter.sh/capacity-type\"] = \"on-demand\"

    # Set resource requests to match Fargate minimums (0.25 vCPU, 0.5GB RAM)
    if \"containers\" in pod_spec[\"spec\"]:
        for container in pod_spec[\"spec\"][\"containers\"]:
            if \"resources\" not in container:
                container[\"resources\"] = {\"requests\": {}, \"limits\": {}}
            if \"requests\" not in container[\"resources\"]:
                container[\"resources\"][\"requests\"] = {}
            # Enforce Fargate minimum vCPU request
            if \"cpu\" not in container[\"resources\"][\"requests\"]:
                container[\"resources\"][\"requests\"][\"cpu\"] = \"0.25\"
                logger.info(f\"Set default vCPU request for container {container['name']}\")
            # Enforce Fargate minimum memory request
            if \"memory\" not in container[\"resources\"][\"requests\"]:
                container[\"resources\"][\"requests\"][\"memory\"] = \"512Mi\"
                logger.info(f\"Set default memory request for container {container['name']}\")

    return pod_spec

def main() -> None:
    load_kube_config()
    api = client.CoreV1Api()

    # List all pods in production namespace
    namespace = \"production\"
    try:
        pods = api.list_namespaced_pod(namespace, label_selector=\"tier=backend\")
        logger.info(f\"Found {len(pods.items)} backend pods in {namespace}\")
    except ApiException as e:
        logger.error(f\"Failed to list pods: {e}\")
        sys.exit(1)

    # Migrate each pod spec (dry run first)
    dry_run = True
    for pod in pods.items:
        pod_name = pod.metadata.name
        original_spec = pod.to_dict()
        migrated_spec = migrate_pod_to_fargate(original_spec)

        if dry_run:
            logger.info(f\"Dry run: Migrated spec for {pod_name}\")
            with open(f\"migrated_{pod_name}.yaml\", \"w\") as f:
                yaml.dump(migrated_spec, f)
        else:
            # Apply migrated spec (requires pod restart)
            logger.info(f\"Applying migrated spec for {pod_name}\")
            try:
                api.replace_namespaced_pod(pod_name, namespace, migrated_spec)
            except ApiException as e:
                logger.error(f\"Failed to update pod {pod_name}: {e}\")

if __name__ == \"__main__\":
    main()

package main

import (
    \"context\"
    \"encoding/json\"
    \"fmt\"
    \"log\"
    \"math/rand\"
    \"os\"
    \"time\"

    \"github.com/aws/aws-sdk-go-v2/aws\"
    \"github.com/aws/aws-sdk-go-v2/config\"
    \"github.com/aws/aws-sdk-go-v2/service/ecs\"
    \"github.com/aws/aws-sdk-go-v2/service/ecs/types\"
)

// BenchmarkResult stores startup time metrics for a compute type
type BenchmarkResult struct {
    ComputeType    string        `json:\"compute_type\"`
    PodCount       int           `json:\"pod_count\"`
    AvgStartupTime time.Duration `json:\"avg_startup_time_ms\"`
    P99StartupTime time.Duration `json:\"p99_startup_time_ms\"`
    ErrorCount     int           `json:\"error_count\"`
}

func main() {
    // Load AWS config from environment
    cfg, err := config.LoadDefaultConfig(context.TODO(), config.WithRegion(\"us-east-1\"))
    if err != nil {
        log.Fatalf(\"Failed to load AWS config: %v\", err)
    }

    // Initialize ECS client for Fargate and EC2 launch types
    ecsClient := ecs.NewFromConfig(cfg)

    // Run benchmark for Fargate 2026 launch type
    fargateResult := runBenchmark(ecsClient, \"FARGATE\", 100)
    // Run benchmark for EC2 launch type
    ec2Result := runBenchmark(ecsClient, \"EC2\", 100)

    // Print results as JSON
    results := []BenchmarkResult{fargateResult, ec2Result}
    jsonData, err := json.MarshalIndent(results, \"\", \"  \")
    if err != nil {
        log.Fatalf(\"Failed to marshal results: %v\", err)
    }
    fmt.Println(string(jsonData))

    // Write to file for reporting
    os.WriteFile(\"benchmark_results.json\", jsonData, 0644)
}

func runBenchmark(client *ecs.Client, launchType string, podCount int) BenchmarkResult {
    log.Printf(\"Running benchmark for launch type: %s, pod count: %d\", launchType, podCount)
    result := BenchmarkResult{
        ComputeType: launchType,
        PodCount:    podCount,
    }

    var startupTimes []time.Duration
    errorCount := 0

    for i := 0; i < podCount; i++ {
        taskName := fmt.Sprintf(\"benchmark-task-%s-%d\", launchType, rand.Intn(10000))
        startTime := time.Now()

        // Run a simple nginx task to measure startup time
        _, err := client.RunTask(context.TODO(), &ecs.RunTaskInput{
            Cluster:        aws.String(\"production-ecs-cluster\"),
            TaskDefinition: aws.String(\"nginx:1.25\"),
            LaunchType:     types.LaunchType(launchType),
            Count:          aws.Int32(1),
            Group:          aws.String(taskName),
            Overrides: &types.TaskOverride{
                ContainerOverrides: []types.ContainerOverride{
                    {
                        Name: aws.String(\"nginx\"),
                        // Override command to exit immediately after startup
                        Command: []string{\"sh\", \"-c\", \"sleep 1 && exit 0\"},
                    },
                },
            },
        })

        if err != nil {
            log.Printf(\"Failed to run task %s: %v\", taskName, err)
            errorCount++
            continue
        }

        // Wait for task to reach RUNNING state
        taskArn := \"\"
        for {
            time.Sleep(1 * time.Second)
            tasks, err := client.ListTasks(context.TODO(), &ecs.ListTasksInput{
                Cluster: aws.String(\"production-ecs-cluster\"),
                Group:   aws.String(taskName),
            })
            if err != nil {
                log.Printf(\"Failed to list tasks for %s: %v\", taskName, err)
                errorCount++
                break
            }

            if len(tasks.TaskArns) == 0 {
                continue
            }

            taskArn = tasks.TaskArns[0]
            taskDetails, err := client.DescribeTasks(context.TODO(), &ecs.DescribeTasksInput{
                Cluster: aws.String(\"production-ecs-cluster\"),
                Tasks:   []string{taskArn},
            })
            if err != nil {
                log.Printf(\"Failed to describe task %s: %v\", taskArn, err)
                errorCount++
                break
            }

            if len(taskDetails.Tasks) == 0 {
                continue
            }

            task := taskDetails.Tasks[0]
            if task.LastStatus == \"RUNNING\" {
                startupTime := time.Since(startTime)
                startupTimes = append(startupTimes, startupTime)
                log.Printf(\"Task %s started in %v\", taskName, startupTime)
                // Stop the task to clean up
                client.StopTask(context.TODO(), &ecs.StopTaskInput{
                    Cluster: aws.String(\"production-ecs-cluster\"),
                    Task:    aws.String(taskArn),
                    Reason:  aws.String(\"benchmark complete\"),
                })
                break
            }
        }
    }

    // Calculate average and p99
    if len(startupTimes) > 0 {
        var total time.Duration
        for _, t := range startupTimes {
            total += t
        }
        result.AvgStartupTime = total / time.Duration(len(startupTimes))

        // Sort times for p99
        // Simple sort for small slices
        for i := 0; i < len(startupTimes)-1; i++ {
            for j := i + 1; j < len(startupTimes); j++ {
                if startupTimes[i] > startupTimes[j] {
                    startupTimes[i], startupTimes[j] = startupTimes[j], startupTimes[i]
                }
            }
        }
        p99Index := int(float64(len(startupTimes)) * 0.99)
        if p99Index >= len(startupTimes) {
            p99Index = len(startupTimes) - 1
        }
        result.P99StartupTime = startupTimes[p99Index]
    }

    result.ErrorCount = errorCount
    return result
}

const AWS = require('aws-sdk');
const { program } = require('commander');

// Configure AWS SDK
AWS.config.update({ region: 'us-east-1' });
const pricing = new AWS.Pricing();

// EC2 instance types we were using pre-migration
const EC2_INSTANCE_TYPES = ['m6i.xlarge', 'm6i.2xlarge', 'c7g.large'];
// Fargate vCPU/RAM configurations post-migration
const FARGATE_CONFIGS = [
  { vCPU: 0.25, memoryGB: 0.5 },
  { vCPU: 1, memoryGB: 2 },
  { vCPU: 2, memoryGB: 4 },
  { vCPU: 4, memoryGB: 8 },
];

/**
 * Fetch on-demand pricing for an EC2 instance type
 * @param {string} instanceType - EC2 instance type (e.g., m6i.xlarge)
 * @returns {Promise} Hourly price in USD
 */
async function getEC2Pricing(instanceType) {
  return new Promise((resolve, reject) => {
    const params = {
      ServiceCode: 'AmazonEC2',
      Filters: [
        { Field: 'instanceType', Value: instanceType, Type: 'TERM_MATCH' },
        { Field: 'location', Value: 'US East (N. Virginia)', Type: 'TERM_MATCH' },
        { Field: 'operatingSystem', Value: 'Linux', Type: 'TERM_MATCH' },
        { Field: 'tenancy', Value: 'Shared', Type: 'TERM_MATCH' },
      ],
      MaxResults: 10,
    };

    pricing.getProducts(params, (err, data) => {
      if (err) {
        reject(new Error(`Failed to fetch EC2 pricing for ${instanceType}: ${err.message}`));
        return;
      }

      try {
        const priceItem = data.PriceList[0];
        const priceDimensions = Object.values(priceItem.terms.OnDemand)[0].priceDimensions;
        const hourlyPrice = Object.values(priceDimensions)[0].pricePerUnit.USD;
        resolve(parseFloat(hourlyPrice));
      } catch (e) {
        reject(new Error(`Failed to parse EC2 pricing for ${instanceType}: ${e.message}`));
      }
    });
  });
}

/**
 * Fetch on-demand pricing for Fargate vCPU and memory
 * @returns {Promise<{vCPUPrice: number, memoryPrice: number}>} Hourly price per vCPU and per GB
 */
async function getFargatePricing() {
  return new Promise((resolve, reject) => {
    const params = {
      ServiceCode: 'AmazonECS',
      Filters: [
        { Field: 'location', Value: 'US East (N. Virginia)', Type: 'TERM_MATCH' },
        { Field: 'service', Value: 'Fargate', Type: 'TERM_MATCH' },
      ],
      MaxResults: 10,
    };

    pricing.getProducts(params, (err, data) => {
      if (err) {
        reject(new Error(`Failed to fetch Fargate pricing: ${err.message}`));
        return;
      }

      try {
        const fargateProducts = data.PriceList.filter(p => {
          const attributes = p.product.attributes;
          return attributes.type === 'vCPU' || attributes.type === 'Memory';
        });

        let vCPUPrice = 0;
        let memoryPrice = 0;

        fargateProducts.forEach(p => {
          const priceDimensions = Object.values(p.terms.OnDemand)[0].priceDimensions;
          const hourlyPrice = Object.values(priceDimensions)[0].pricePerUnit.USD;
          if (p.product.attributes.type === 'vCPU') {
            vCPUPrice = parseFloat(hourlyPrice);
          } else if (p.product.attributes.type === 'Memory') {
            memoryPrice = parseFloat(hourlyPrice);
          }
        });

        resolve({ vCPUPrice, memoryPrice });
      } catch (e) {
        reject(new Error(`Failed to parse Fargate pricing: ${e.message}`));
      }
    });
  });
}

/**
 * Calculate monthly cost for EC2 workload
 * @param {Object} workload - Workload spec with instance type and count
 * @param {number} hourlyPrice - EC2 hourly price
 * @returns {number} Monthly cost in USD
 */
function calculateEC2Cost(workload, hourlyPrice) {
  const hoursPerMonth = 730; // Average hours in a month
  return workload.count * hourlyPrice * hoursPerMonth;
}

/**
 * Calculate monthly cost for Fargate workload
 * @param {Object} workload - Workload spec with vCPU and memory requirements
 * @param {number} vCPUPrice - Fargate vCPU hourly price
 * @param {number} memoryPrice - Fargate memory hourly price
 * @returns {number} Monthly cost in USD
 */
function calculateFargateCost(workload, vCPUPrice, memoryPrice) {
  const hoursPerMonth = 730;
  const vCPUCost = workload.vCPU * vCPUPrice * hoursPerMonth;
  const memoryCost = workload.memoryGB * memoryPrice * hoursPerMonth;
  return vCPUCost + memoryCost;
}

async function main() {
  program
    .option('--ec2-instance ', 'EC2 instance type', 'm6i.xlarge')
    .option('--ec2-count ', 'Number of EC2 instances', '10')
    .option('--fargate-vcpu ', 'Fargate vCPU per pod', '1')
    .option('--fargate-memory ', 'Fargate memory per pod (GB)', '2')
    .option('--fargate-pod-count ', 'Number of Fargate pods', '20')
    .parse();

  const options = program.opts();

  try {
    // Fetch pricing
    const ec2Price = await getEC2Pricing(options.ec2Instance);
    const { vCPUPrice, memoryPrice } = await getFargatePricing();

    // Calculate EC2 cost
    const ec2Workload = { count: parseInt(options.ec2Count) };
    const ec2Cost = calculateEC2Cost(ec2Workload, ec2Price);

    // Calculate Fargate cost
    const fargateWorkload = {
      vCPU: parseFloat(options.fargateVcpu),
      memoryGB: parseFloat(options.fargateMemory),
      count: parseInt(options.fargatePodCount),
    };
    // Fargate cost is per pod, so multiply by pod count
    const fargateCost = calculateFargateCost(fargateWorkload, vCPUPrice, memoryPrice) * fargateWorkload.count;

    // Calculate savings
    const savings = ec2Cost - fargateCost;
    const savingsPercent = (savings / ec2Cost) * 100;

    console.log('=== Cost Comparison ===');
    console.log(`EC2 (${options.ec2Instance} x ${options.ec2Count}): $${ec2Cost.toFixed(2)}/month`);
    console.log(`Fargate (${options.fargateVcpu} vCPU, ${options.fargateMemory}GB x ${options.fargatePodCount}): $${fargateCost.toFixed(2)}/month`);
    console.log(`Monthly Savings: $${savings.toFixed(2)} (${savingsPercent.toFixed(1)}%)`);
  } catch (err) {
    console.error(`Error calculating costs: ${err.message}`);
    process.exit(1);
  }
}

main();

# Karpenter 1.1 admission controller configuration for Fargate validation
apiVersion: karpenter.sh/v1alpha1
kind: AdmissionController
metadata:
  name: fargate-resource-validator
spec:
  validationRules:
    - name: fargate-min-resources
      match:
        labelSelector:
          matchLabels:
            compute-type: fargate
      validate:
        - path: \"spec.containers[*].resources.requests.cpu\"
          min: \"0.25\"
          message: \"Fargate requires minimum 0.25 vCPU request\"
        - path: \"spec.containers[*].resources.requests.memory\"
          min: \"512Mi\"
          message: \"Fargate requires minimum 512Mi memory request\"
    - name: fargate-max-resources
      match:
        labelSelector:
          matchLabels:
            workload-type: web
      validate:
        - path: \"spec.containers[*].resources.requests.cpu\"
          max: \"4\"
          message: \"Web workloads max 4 vCPU on Fargate\"

# Fargate 2026 pre-warmed pool configuration via Karpenter 1.1
apiVersion: karpenter.sh/v1alpha1
kind: FargatePool
metadata:
  name: flash-sale-prewarmed-pool
spec:
  minSize: 10
  maxSize: 50
  podTemplate:
    spec:
      containers:
        - name: flash-sale-api
          image: myorg/flash-sale:v1.2.3
          resources:
            requests:
              cpu: \"1\"
              memory: \"2Gi\"
  scalingPolicy:
    targetUtilization: 0.8
    scaleUpCooldown: 30s
    scaleDownCooldown: 5m
  preWarmConfig:
    enabled: true
    warmRate: 5 # pods per minute
    historyWindow: 7d # use 7 days of traffic data to size pool

# Prometheus query to find underutilized Fargate pods (CPU <30% for 7d)
avg_over_time(
  rate(container_cpu_usage_seconds_total{container!=\"POD\", compute_type=\"fargate\"}[5m])[7d:5m]
) / 
avg_over_time(
  kube_pod_container_resource_requests{resource=\"cpu\", compute_type=\"fargate\"}[7d:5m]
) < 0.3