Comparison: EKS vs. GKE vs. AKS for Managed Kubernetes 1.34 Clusters: Cost, Performance, and Features

# Terraform configuration for EKS 1.34 cluster with Karpenter autoscaler
# Provider versions pinned to ensure compatibility with K8s 1.34
terraform {
  required_version = \">= 1.7.0\"
  required_providers {
    aws = {
      source  = \"hashicorp/aws\"
      version = \"~> 5.31.0\" # AWS provider 5.31+ adds native K8s 1.34 support
    }
    kubernetes = {
      source  = \"hashicorp/kubernetes\"
      version = \"~> 2.23.0\"
    }
    helm = {
      source  = \"hashicorp/helm\"
      version = \"~> 2.12.0\"
    }
  }
}

# Configure AWS provider with error handling for missing credentials
provider \"aws\" {
  region = var.aws_region

  default_tags {
    tags = {
      Project     = \"eks-1-34-benchmark\"
      Environment = \"production\"
      ManagedBy   = \"terraform\"
    }
  }
}

# Variables with validation
variable \"aws_region\" {
  type        = string
  description = \"AWS region to deploy EKS cluster\"
  default     = \"us-east-1\"
  validation {
    condition     = contains([\"us-east-1\", \"us-west-2\", \"eu-west-1\"], var.aws_region)
    error_message = \"Region must be a supported EKS 1.34 region.\"
  }
}

variable \"cluster_name\" {
  type        = string
  description = \"Name of the EKS cluster\"
  default     = \"eks-1-34-cluster\"
}

variable \"k8s_version\" {
  type        = string
  description = \"Kubernetes version (must be 1.34.x)\"
  default     = \"1.34.0\"
  validation {
    condition     = can(regex(\"^1\\\\.34\\\\.[0-9]+$\", var.k8s_version))
    error_message = \"Kubernetes version must be 1.34.x.\"
  }
}

# IAM role for EKS cluster with proper trust policy
resource \"aws_iam_role\" \"eks_cluster_role\" {
  name = \"${var.cluster_name}-cluster-role\"

  assume_role_policy = jsonencode({
    Version = \"2012-10-17\"
    Statement = [
      {
        Action = \"sts:AssumeRole\"
        Effect = \"Allow\"
        Principal = {
          Service = \"eks.amazonaws.com\"
        }
      }
    ]
  })

  tags = {
    Name = \"${var.cluster_name}-cluster-role\"
  }
}

resource \"aws_iam_role_policy_attachment\" \"eks_cluster_policy\" {
  role       = aws_iam_role.eks_cluster_role.name
  policy_arn = \"arn:aws:iam::aws:policy/AmazonEKSClusterPolicy\"
}

# EKS cluster resource with 1.34 version pin
resource \"aws_eks_cluster\" \"main\" {
  name     = var.cluster_name
  role_arn = aws_iam_role.eks_cluster_role.arn
  version  = var.k8s_version

  vpc_config {
    subnet_ids = aws_subnet.eks_subnets[*].id
    endpoint_private_access = true
    endpoint_public_access  = true
  }

  # Ensure IAM role is created before cluster
  depends_on = [
    aws_iam_role_policy_attachment.eks_cluster_policy,
  ]

  tags = {
    Name = var.cluster_name
  }
}

# Subnets for EKS (simplified for example)
resource \"aws_vpc\" \"eks_vpc\" {
  cidr_block = \"10.0.0.0/16\"
  tags = {
    Name = \"${var.cluster_name}-vpc\"
  }
}

resource \"aws_subnet\" \"eks_subnets\" {
  count = 2
  vpc_id = aws_vpc.eks_vpc.id
  cidr_block = \"10.0.${count.index}.0/24\"
  availability_zone = \"${var.aws_region}${count.index == 0 ? \"a\" : \"b\"}\"
  tags = {
    Name = \"${var.cluster_name}-subnet-${count.index}\"
    \"kubernetes.io/cluster/${var.cluster_name}\" = \"shared\"
  }
}

# Karpenter 1.0 installation via Helm
resource \"helm_release\" \"karpenter\" {
  name       = \"karpenter\"
  repository = \"oci://public.ecr.aws/karpenter\"
  chart      = \"karpenter\"
  version    = \"1.0.0\" # Karpenter 1.0 is compatible with K8s 1.34
  namespace  = \"karpenter\"

  set {
    name  = \"controller.clusterName\"
    value = aws_eks_cluster.main.name
  }

  set {
    name  = \"controller.clusterEndpoint\"
    value = aws_eks_cluster.main.endpoint
  }
}

#!/usr/bin/env python3
\"\"\"
Pod startup latency benchmark for EKS, GKE, AKS Kubernetes 1.34 clusters.
Benchmarks 1000 pod startups per cluster, records p50/p95/p99 latency.
\"\"\"

import os
import time
import json
import argparse
import subprocess
from typing import Dict, List, Optional
from dataclasses import dataclass

@dataclass
class BenchmarkConfig:
    cluster_type: str  # eks, gke, aks
    kubeconfig_path: str
    namespace: str
    pod_count: int
    pod_image: str
    region: str

class PodLatencyBenchmark:
    def __init__(self, config: BenchmarkConfig):
        self.config = config
        self.results: List[float] = []
        self._validate_kubeconfig()

    def _validate_kubeconfig(self) -> None:
        \"\"\"Check if kubeconfig exists and is accessible.\"\"\"
        if not os.path.exists(self.config.kubeconfig_path):
            raise FileNotFoundError(
                f\"Kubeconfig not found at {self.config.kubeconfig_path}\"
            )
        # Test cluster connectivity
        try:
            subprocess.run(
                [\"kubectl\", \"--kubeconfig\", self.config.kubeconfig_path, \"cluster-info\"],
                check=True,
                capture_output=True,
                timeout=30
            )
        except subprocess.CalledProcessError as e:
            raise ConnectionError(
                f\"Failed to connect to {self.config.cluster_type} cluster: {e.stderr.decode()}\"
            ) from e

    def _create_pod_manifest(self, pod_id: int) -> Dict:
        \"\"\"Generate pod manifest for benchmark pod.\"\"\"
        return {
            \"apiVersion\": \"v1\",
            \"kind\": \"Pod\",
            \"metadata\": {
                \"name\": f\"latency-bench-{pod_id}\",
                \"namespace\": self.config.namespace,
                \"labels\": {\"app\": \"latency-bench\"}
            },
            \"spec\": {
                \"containers\": [{
                    \"name\": \"pause\",
                    \"image\": self.config.pod_image,
                    \"resources\": {\"requests\": {\"cpu\": \"10m\", \"memory\": \"16Mi\"}}
                }],
                \"terminationGracePeriodSeconds\": 1
            }
        }

    def run_benchmark(self) -> None:
        \"\"\"Execute 1000 pod startups and record latency.\"\"\"
        print(f\"Starting benchmark for {self.config.cluster_type} cluster...\")
        for pod_id in range(self.config.pod_count):
            start_time = time.perf_counter()
            # Create pod
            manifest = self._create_pod_manifest(pod_id)
            try:
                subprocess.run(
                    [\"kubectl\", \"--kubeconfig\", self.config.kubeconfig_path,
                     \"apply\", \"-f\", \"-\"],
                    input=json.dumps(manifest).encode(),
                    check=True,
                    capture_output=True,
                    timeout=10
                )
                # Wait for pod to be running
                subprocess.run(
                    [\"kubectl\", \"--kubeconfig\", self.config.kubeconfig_path,
                     \"wait\", \"--for=condition=Ready\", f\"pod/latency-bench-{pod_id}\",
                     \"--timeout=30s\", \"-n\", self.config.namespace],
                    check=True,
                    capture_output=True,
                    timeout=35
                )
                end_time = time.perf_counter()
                latency_ms = (end_time - start_time) * 1000
                self.results.append(latency_ms)
                # Clean up pod
                subprocess.run(
                    [\"kubectl\", \"--kubeconfig\", self.config.kubeconfig_path,
                     \"delete\", \"pod\", f\"latency-bench-{pod_id}\", \"-n\", self.config.namespace],
                    check=True,
                    capture_output=True,
                    timeout=10
                )
            except subprocess.TimeoutExpired:
                print(f\"Pod {pod_id} timed out, skipping...\")
                continue
            except subprocess.CalledProcessError as e:
                print(f\"Failed to start pod {pod_id}: {e.stderr.decode()}\")
                continue

    def export_results(self, output_path: str) -> None:
        \"\"\"Export benchmark results to JSON.\"\"\"
        if not self.results:
            raise ValueError(\"No benchmark results to export.\")
        self.results.sort()
        p50 = self.results[len(self.results) // 2]
        p95 = self.results[int(len(self.results) * 0.95)]
        p99 = self.results[int(len(self.results) * 0.99)]
        report = {
            \"cluster_type\": self.config.cluster_type,
            \"k8s_version\": \"1.34.0\",
            \"pod_count\": len(self.results),
            \"p50_latency_ms\": round(p50, 2),
            \"p95_latency_ms\": round(p95, 2),
            \"p99_latency_ms\": round(p99, 2),
            \"region\": self.config.region
        }
        with open(output_path, \"w\") as f:
            json.dump(report, f, indent=2)
        print(f\"Results exported to {output_path}\")

if __name__ == \"__main__\":
    parser = argparse.ArgumentParser(description=\"K8s 1.34 pod startup latency benchmark\")
    parser.add_argument(\"--cluster-type\", required=True, choices=[\"eks\", \"gke\", \"aks\"])
    parser.add_argument(\"--kubeconfig\", required=True)
    parser.add_argument(\"--namespace\", default=\"default\")
    parser.add_argument(\"--pod-count\", type=int, default=1000)
    parser.add_argument(\"--image\", default=\"registry.k8s.io/pause:3.9\")
    parser.add_argument(\"--region\", default=\"us-east1\")
    parser.add_argument(\"--output\", default=\"benchmark_results.json\")
    args = parser.parse_args()

    config = BenchmarkConfig(
        cluster_type=args.cluster_type,
        kubeconfig_path=args.kubeconfig,
        namespace=args.namespace,
        pod_count=args.pod_count,
        pod_image=args.image,
        region=args.region
    )

    try:
        benchmark = PodLatencyBenchmark(config)
        benchmark.run_benchmark()
        benchmark.export_results(args.output)
    except Exception as e:
        print(f\"Benchmark failed: {str(e)}\")
        exit(1)

package main

import (
    \"encoding/csv\"
    \"fmt\"
    \"log\"
    \"os\"
    \"time\"
)

// NodeConfig represents a cloud provider node type
type NodeConfig struct {
    Provider     string
    NodeType     string
    Region       string
    CPU          int
    MemoryGB     int
    CostPerHour  float64
    SpotDiscount float64 // 0.0 to 1.0
}

// ClusterConfig represents a K8s cluster configuration
type ClusterConfig struct {
    Name       string
    K8sVersion string
    NodeCount  int
    Nodes      []NodeConfig
    ManagedFee float64 // Monthly managed service fee
}

// TCOResult holds total cost of ownership for 12 months
type TCOResult struct {
    Provider     string
    ClusterName  string
    Region       string
    NodeCost     float64
    ManagedFee   float64
    Total12Month float64
    SpotSavings  float64
}

func calculateNodeCost(nodes []NodeConfig, hours int, useSpot bool) float64 {
    total := 0.0
    for _, node := range nodes {
        cost := node.CostPerHour
        if useSpot {
            cost *= (1 - node.SpotDiscount)
        }
        total += cost * float64(hours) * float64(len(nodes))
    }
    return total
}

func calculateTCO(cluster ClusterConfig, months int, useSpot bool) TCOResult {
    hoursPerMonth := 24 * 30 // Approximate
    totalHours := hoursPerMonth * months

    nodeCost := calculateNodeCost(cluster.Nodes, totalHours, useSpot)
    managedFee := cluster.ManagedFee * float64(months)
    total := nodeCost + managedFee

    spotSavings := 0.0
    if useSpot {
        onDemandCost := calculateNodeCost(cluster.Nodes, totalHours, false)
        spotSavings = onDemandCost - nodeCost
    }

    return TCOResult{
        Provider:     cluster.Nodes[0].Provider,
        ClusterName:  cluster.Name,
        Region:       cluster.Nodes[0].Region,
        NodeCost:     nodeCost,
        ManagedFee:   managedFee,
        Total12Month: total,
        SpotSavings:  spotSavings,
    }
}

func exportToCSV(results []TCOResult, filename string) error {
    file, err := os.Create(filename)
    if err != nil {
        return fmt.Errorf(\"failed to create CSV: %w\", err)
    }
    defer file.Close()

    writer := csv.NewWriter(file)
    defer writer.Flush()

    // Write header
    header := []string{\"Provider\", \"Cluster\", \"Region\", \"Node Cost (12m)\", \"Managed Fee (12m)\", \"Total (12m)\", \"Spot Savings\"}
    if err := writer.Write(header); err != nil {
        return fmt.Errorf(\"failed to write header: %w\", err)
    }

    // Write rows
    for _, res := range results {
        row := []string{
            res.Provider,
            res.ClusterName,
            res.Region,
            fmt.Sprintf(\"%.2f\", res.NodeCost),
            fmt.Sprintf(\"%.2f\", res.ManagedFee),
            fmt.Sprintf(\"%.2f\", res.Total12Month),
            fmt.Sprintf(\"%.2f\", res.SpotSavings),
        }
        if err := writer.Write(row); err != nil {
            return fmt.Errorf(\"failed to write row: %w\", err)
        }
    }
    return nil
}

func main() {
    // Benchmark methodology: 20-node cluster, m5.xlarge equivalent, us-east1, 12 months
    clusters := []ClusterConfig{
        {
            Name:       \"eks-1-34-cluster\",
            K8sVersion: \"1.34.0\",
            NodeCount:  20,
            Nodes: []NodeConfig{
                {
                    Provider:     \"AWS EKS\",
                    NodeType:     \"m5.xlarge\",
                    Region:       \"us-east-1\",
                    CPU:          4,
                    MemoryGB:     16,
                    CostPerHour:  0.192, // On-demand m5.xlarge us-east-1
                    SpotDiscount: 0.7,   // 70% spot discount for m5.xlarge
                },
            },
            ManagedFee: 73.0, // EKS monthly managed fee per cluster
        },
        {
            Name:       \"gke-1-34-cluster\",
            K8sVersion: \"1.34.0\",
            NodeCount:  20,
            Nodes: []NodeConfig{
                {
                    Provider:     \"Google GKE\",
                    NodeType:     \"e2-standard-4\",
                    Region:       \"us-east1\",
                    CPU:          4,
                    MemoryGB:     16,
                    CostPerHour:  0.167, // On-demand e2-standard-4 us-east1
                    SpotDiscount: 0.75,  // 75% spot discount for e2-standard-4
                },
            },
            ManagedFee: 0.0, // GKE standard has no per-cluster fee
        },
        {
            Name:       \"aks-1-34-cluster\",
            K8sVersion: \"1.34.0\",
            NodeCount:  20,
            Nodes: []NodeConfig{
                {
                    Provider:     \"Azure AKS\",
                    NodeType:     \"Standard_D4s_v5\",
                    Region:       \"eastus\",
                    CPU:          4,
                    MemoryGB:     16,
                    CostPerHour:  0.18, // On-demand D4s_v5 eastus
                    SpotDiscount: 0.68, // 68% spot discount for D4s_v5
                },
            },
            ManagedFee: 0.0, // AKS has no per-cluster fee
        },
    }

    var results []TCOResult
    for _, cluster := range clusters {
        // Calculate on-demand TCO
        onDemandRes := calculateTCO(cluster, 12, false)
        results = append(results, onDemandRes)

        // Calculate spot TCO
        spotRes := calculateTCO(cluster, 12, true)
        results = append(results, spotRes)
    }

    // Export results
    if err := exportToCSV(results, \"tco_results.csv\"); err != nil {
        log.Fatalf(\"Failed to export results: %v\", err)
    }

    // Print summary
    fmt.Println(\"12-Month TCO Summary (20-node cluster, us-east1/eastus):\")
    for _, res := range results {
        fmt.Printf(\"%s (%s) - Total: $%.2f, Spot Savings: $%.2f\\n\",
            res.Provider, res.ClusterName, res.Total12Month, res.SpotSavings)
    }
}

apiVersion: karpenter.sh/v1
kind: NodePool
metadata:
  name: default
spec:
  template:
    spec:
      requirements:
        - key: node.kubernetes.io/instance-type
          operator: In
          values: [\"m5.xlarge\", \"m5.2xlarge\"]
        - key: karpenter.sh/capacity-type
          operator: In
          values: [\"spot\", \"on-demand\"]
      nodeClassRef:
        name: default
  limits:
    cpu: \"1000\"
    memory: \"4000Gi\"
  disruption:
    consolidationPolicy: WhenUnderutilized
    expireAfter: 720h # 30 days

gcloud container clusters create-auto benchmark-autopilot \\
  --region=us-east1 \\
  --cluster-version=1.34.0 \\
  --project=your-gcp-project \\
  --enable-ip-alias

az aks nodepool add \\
  --resource-group myResourceGroup \\
  --cluster-name myAKSCluster \\
  --name win22nodepool \\
  --node-count 3 \\
  --node-vm-size Standard_D4s_v5 \\
  --os-type Windows \\
  --os-sku Windows2022