Opinion: AWS Graviton4 Is the Only Node Type You Need for Kubernetes 1.32 in 2026 – x86 Is Obsolete

# Terraform 1.9.0+ configuration for provisioning EKS 1.32 node groups
# Compares Graviton4 (c8g) vs x86 (c7i) node pools with identical specs
# Author: Senior Engineer, 15y exp, InfoQ/ACM Queue contributor
# All instance types are us-east-1 regional equivalents for 2026 pricing

terraform {
  required_version = ">= 1.9.0"
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.40"
    }
    kubernetes = {
      source  = "hashicorp/kubernetes"
      version = "~> 2.30"
    }
  }
}

# Validation: Ensure EKS version is 1.32 as required
variable "eks_cluster_version" {
  type        = string
  default     = "1.32"
  description = "EKS cluster Kubernetes version, must be 1.32 for Graviton4 optimizations"

  validation {
    condition     = var.eks_cluster_version == "1.32"
    error_message = "This configuration only supports EKS 1.32 for Graviton4 scheduler optimizations."
  }
}

# Graviton4 node group configuration (c8g.medium: 1 vCPU, 2GB RAM, $0.0385/hour as of 2026)
resource "aws_eks_node_group" "graviton4_nodes" {
  cluster_name    = var.eks_cluster_name
  node_group_name = "graviton4-c8g-medium-1.32"
  node_role_arn   = var.eks_node_role_arn
  subnet_ids      = var.private_subnet_ids
  instance_types  = ["c8g.medium"] # Graviton4-based general purpose instance

  # ARM64 taint to ensure only arm64-compatible pods are scheduled here
  taint {
    key    = "arch"
    value  = "arm64"
    effect = "NO_SCHEDULE"
  }

  scaling_config {
    desired_size = 2
    max_size     = 10
    min_size     = 1
  }

  # Kubernetes 1.32-specific labels for scheduler optimization
  labels = {
    "node.kubernetes.io/arch"       = "arm64"
    "eks.amazonaws.com/instance-type" = "c8g.medium"
    "workload-optimization"          = "graviton4-1.32"
  }

  # Error handling: Ensure node group is healthy before marking complete
  timeouts {
    create = "30m"
    update = "30m"
    delete = "30m"
  }

  tags = {
    "CostCenter" = "Compute-2026"
    "Architecture" = "ARM64-Graviton4"
  }
}

# x86 node group configuration (c7i.medium: 1 vCPU, 2GB RAM, $0.065/hour as of 2026)
resource "aws_eks_node_group" "x86_nodes" {
  cluster_name    = var.eks_cluster_name
  node_group_name = "x86-c7i-medium-1.32"
  node_role_arn   = var.eks_node_role_arn
  subnet_ids      = var.private_subnet_ids
  instance_types  = ["c7i.medium"] # Intel Sapphire Rapids-based x86 instance

  # x86 taint to separate architectures
  taint {
    key    = "arch"
    value  = "amd64"
    effect = "NO_SCHEDULE"
  }

  scaling_config {
    desired_size = 2
    max_size     = 10
    min_size     = 1
  }

  labels = {
    "node.kubernetes.io/arch"       = "amd64"
    "eks.amazonaws.com/instance-type" = "c7i.medium"
    "workload-optimization"          = "x86-legacy"
  }

  timeouts {
    create = "30m"
    update = "30m"
    delete = "30m"
  }

  tags = {
    "CostCenter" = "Compute-2026"
    "Architecture" = "x86-Legacy"
  }
}

# Output node group ARNs for verification
output "graviton4_node_group_arn" {
  value       = aws_eks_node_group.graviton4_nodes.arn
  description = "ARN of the Graviton4 node group"
}

output "x86_node_group_arn" {
  value       = aws_eks_node_group.x86_nodes.arn
  description = "ARN of the x86 node group"
}

// graviton-validator: Go-based Kubernetes 1.32 operator to validate pod scheduling on Graviton4 nodes
// Author: Senior Engineer, 15y exp, InfoQ/ACM Queue contributor
// Requires k8s.io/client-go v1.32.0+, Go 1.23+
package main

import (
    "context"
    "flag"
    "fmt"
    "os"
    "time"

    corev1 "k8s.io/api/core/v1"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "k8s.io/client-go/kubernetes"
    "k8s.io/client-go/tools/clientcmd"
    "k8s.io/client-go/util/homedir"
    "go.uber.org/zap"
    "go.uber.org/zap/zapcore"
)

var (
    kubeconfig *string
    log        *zap.Logger
)

func initLogger() {
    config := zap.NewProductionConfig()
    config.EncoderConfig.TimeKey = "timestamp"
    config.EncoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
    var err error
    log, err = config.Build()
    if err != nil {
        fmt.Printf("Failed to initialize logger: %v\n", err)
        os.Exit(1)
    }
}

func getClientSet() (*kubernetes.Clientset, error) {
    if home := homedir.HomeDir(); home != "" {
        *kubeconfig = flag.String("kubeconfig", filepath.Join(home, ".kube", "config"), "(optional) absolute path to the kubeconfig file")
    } else {
        *kubeconfig = flag.String("kubeconfig", "", "absolute path to the kubeconfig file")
    }
    flag.Parse()

    config, err := clientcmd.BuildConfigFromFlags("", *kubeconfig)
    if err != nil {
        log.Error("Failed to build kubeconfig", zap.Error(err))
        return nil, fmt.Errorf("kubeconfig error: %w", err)
    }

    clientset, err := kubernetes.NewForConfig(config)
    if err != nil {
        log.Error("Failed to create Kubernetes client", zap.Error(err))
        return nil, fmt.Errorf("client error: %w", err)
    }
    return clientset, nil
}

func validatePodScheduling(ctx context.Context, clientset *kubernetes.Clientset) error {
    // List all pods in all namespaces
    pods, err := clientset.CoreV1().Pods("").List(ctx, metav1.ListOptions{})
    if err != nil {
        log.Error("Failed to list pods", zap.Error(err))
        return fmt.Errorf("pod list error: %w", err)
    }

    gravitonCount := 0
    x86Count := 0
    invalidCount := 0

    for _, pod := range pods.Items {
        // Skip pods that are not scheduled yet
        if pod.Spec.NodeName == "" {
            continue
        }

        node, err := clientset.CoreV1().Nodes().Get(ctx, pod.Spec.NodeName, metav1.GetOptions{})
        if err != nil {
            log.Warn("Failed to get node for pod", zap.String("pod", pod.Name), zap.Error(err))
            continue
        }

        arch := node.Labels["node.kubernetes.io/arch"]
        instanceType := node.Labels["eks.amazonaws.com/instance-type"]

        // Check if pod has arch taint toleration matching node
        hasToleration := false
        for _, taint := range node.Spec.Taints {
            for _, toleration := range pod.Spec.Tolerations {
                if toleration.Key == taint.Key && toleration.Value == taint.Value {
                    hasToleration = true
                    break
                }
            }
            if hasToleration {
                break
            }
        }

        if !hasToleration {
            log.Warn("Pod does not tolerate node taint",
                zap.String("pod", pod.Name),
                zap.String("node", node.Name),
                zap.String("arch", arch))
            invalidCount++
            continue
        }

        if arch == "arm64" && instanceType[:2] == "c8g" {
            gravitonCount++
            log.Info("Pod correctly scheduled on Graviton4",
                zap.String("pod", pod.Name),
                zap.String("node", node.Name))
        } else if arch == "amd64" && instanceType[:2] == "c7i" {
            x86Count++
            log.Info("Pod correctly scheduled on x86",
                zap.String("pod", pod.Name),
                zap.String("node", node.Name))
        } else {
            log.Error("Pod scheduled on mismatched architecture",
                zap.String("pod", pod.Name),
                zap.String("nodeArch", arch),
                zap.String("instanceType", instanceType))
            invalidCount++
        }
    }

    log.Info("Scheduling validation complete",
        zap.Int("graviton4-pods", gravitonCount),
        zap.Int("x86-pods", x86Count),
        zap.Int("invalid-schedules", invalidCount))
    return nil
}

func main() {
    initLogger()
    defer log.Sync()

    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
    defer cancel()

    clientset, err := getClientSet()
    if err != nil {
        log.Fatal("Failed to initialize client set", zap.Error(err))
    }

    log.Info("Starting Graviton4 scheduling validator for K8s 1.32")
    if err := validatePodScheduling(ctx, clientset); err != nil {
        log.Fatal("Validation failed", zap.Error(err))
    }
}

#!/usr/bin/env python3
"""
Kubernetes 1.32 Graviton4 vs x86 Benchmark Script
Author: Senior Engineer, 15y exp, InfoQ/ACM Queue contributor
Requires: boto3>=1.34.0, kubernetes>=28.1.0, pandas>=2.2.0
"""

import boto3
import time
import pandas as pd
from kubernetes import client, config
from kubernetes.client.rest import ApiException
import logging
from typing import Dict, List

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

# Constants
EKS_CLUSTER_NAME = "prod-eks-1-32"
REGION = "us-east-1"
BENCHMARK_POD_MANIFEST = {
    "apiVersion": "v1",
    "kind": "Pod",
    "metadata": {"name": "graviton-benchmark", "namespace": "default"},
    "spec": {
        "containers": [{
            "name": "bench",
            "image": "arm64v8/ubuntu:24.04",  # ARM64 base image
            "command": ["/bin/bash", "-c", "sysbench cpu --cpu-max-prime=20000 run && sysbench memory run"],
            "resources": {"requests": {"cpu": "1", "memory": "1Gi"}, "limits": {"cpu": "1", "memory": "1Gi"}}
        }],
        "nodeSelector": {"node.kubernetes.io/arch": "arm64"},
        "tolerations": [{"key": "arch", "value": "arm64", "effect": "NoSchedule"}],
        "restartPolicy": "Never"
    }
}

def init_k8s_client() -> client.CoreV1Api:
    """Initialize Kubernetes client for EKS 1.32 cluster"""
    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 config")
        except Exception as e:
            logger.error(f"Failed to load any k8s config: {e}")
            raise
    return client.CoreV1Api()

def init_aws_clients() -> tuple:
    """Initialize AWS EKS and CloudWatch clients"""
    try:
        eks_client = boto3.client("eks", region_name=REGION)
        cw_client = boto3.client("cloudwatch", region_name=REGION)
        logger.info("Initialized AWS clients")
        return eks_client, cw_client
    except Exception as e:
        logger.error(f"Failed to initialize AWS clients: {e}")
        raise

def schedule_benchmark_pod(api: client.CoreV1Api, arch: str) -> float:
    """Schedule benchmark pod and return startup latency in seconds"""
    pod_name = f"benchmark-{arch}-{int(time.time())}"
    manifest = BENCHMARK_POD_MANIFEST.copy()
    manifest["metadata"]["name"] = pod_name
    manifest["spec"]["nodeSelector"]["node.kubernetes.io/arch"] = arch
    manifest["spec"]["tolerations"][0]["value"] = arch

    # Use amd64 image for x86
    if arch == "amd64":
        manifest["spec"]["containers"][0]["image"] = "amd64/ubuntu:24.04"

    start_time = time.time()
    try:
        api.create_namespaced_pod(namespace="default", body=manifest)
        logger.info(f"Scheduled {arch} benchmark pod: {pod_name}")
    except ApiException as e:
        logger.error(f"Failed to schedule pod: {e}")
        raise

    # Wait for pod to start
    while True:
        try:
            pod = api.read_namespaced_pod(name=pod_name, namespace="default")
            if pod.status.phase in ["Running", "Succeeded", "Failed"]:
                end_time = time.time()
                latency = end_time - start_time
                logger.info(f"{arch} pod startup latency: {latency:.2f}s")
                # Clean up pod
                api.delete_namespaced_pod(name=pod_name, namespace="default", body=client.V1DeleteOptions())
                return latency
        except ApiException as e:
            logger.warning(f"Error reading pod {pod_name}: {e}")
        time.sleep(1)

def get_node_metrics(cw_client, node_group: str) -> Dict:
    """Get CPU utilization metrics for node group"""
    # Simplified metric retrieval for example
    response = cw_client.get_metric_statistics(
        Namespace="ContainerInsights",
        MetricName="node_cpu_utilization",
        Dimensions=[{"Name": "NodeGroup", "Value": node_group}],
        StartTime=time.time() - 3600,
        EndTime=time.time(),
        Period=300,
        Statistics=["Average"]
    )
    avg_cpu = sum(dp["Average"] for dp in response["Datapoints"]) / len(response["Datapoints"]) if response["Datapoints"] else 0
    return {"avg_cpu": avg_cpu}

def main():
    try:
        k8s_api = init_k8s_client()
        eks_client, cw_client = init_aws_clients()
    except Exception as e:
        logger.error(f"Initialization failed: {e}")
        return

    results = []

    # Benchmark Graviton4 (arm64)
    logger.info("Starting Graviton4 benchmark")
    graviton_latency = schedule_benchmark_pod(k8s_api, "arm64")
    graviton_metrics = get_node_metrics(cw_client, "graviton4-c8g-medium-1.32")
    results.append({
        "arch": "arm64-graviton4",
        "startup_latency_s": graviton_latency,
        "avg_cpu_util": graviton_metrics["avg_cpu"],
        "cost_per_vcpu_hour": 0.0385
    })

    # Benchmark x86 (amd64)
    logger.info("Starting x86 benchmark")
    x86_latency = schedule_benchmark_pod(k8s_api, "amd64")
    x86_metrics = get_node_metrics(cw_client, "x86-c7i-medium-1.32")
    results.append({
        "arch": "amd64-x86",
        "startup_latency_s": x86_latency,
        "avg_cpu_util": x86_metrics["avg_cpu"],
        "cost_per_vcpu_hour": 0.065
    })

    # Generate report
    df = pd.DataFrame(results)
    df["price_performance"] = df["cost_per_vcpu_hour"] / (1 / df["startup_latency_s"])  # Lower is better
    logger.info("\nBenchmark Results:\n" + df.to_string())
    df.to_csv("graviton4_vs_x86_benchmark.csv", index=False)
    logger.info("Saved results to graviton4_vs_x86_benchmark.csv")

if __name__ == "__main__":
    main()

# Build and push multi-arch image for Graviton4 and x86
docker buildx build \
  --platform linux/amd64,linux/arm64 \
  -t 123456789012.dkr.ecr.us-east-1.amazonaws.com/myapp:1.32 \
  --push .

# Pod spec with Graviton4 node affinity and toleration
apiVersion: v1
kind: Pod
metadata:
  name: myapp-graviton
spec:
  containers:
  - name: myapp
    image: 123456789012.dkr.ecr.us-east-1.amazonaws.com/myapp:1.32
  nodeSelector:
    node.kubernetes.io/arch: arm64
  tolerations:
  - key: "arch"
    value: "arm64"
    effect: "NoSchedule"

# Boto3 script to create Graviton4 CloudWatch dashboard
import boto3
import json

cw_client = boto3.client("cloudwatch", region_name="us-east-1")

dashboard_body = {
    "widgets": [
        {
            "type": "metric",
            "properties": {
                "metrics": [
                    ["ContainerInsights", "node_cpu_utilization", "NodeGroup", "graviton4-c8g-medium-1.32"]
                ],
                "period": 300,
                "stat": "Average",
                "region": "us-east-1",
                "title": "Graviton4 Node CPU Utilization"
            }
        }
    ]
}

cw_client.put_dashboard(
    DashboardName="Graviton4-EKS-1.32-Metrics",
    DashboardBody=json.dumps(dashboard_body)
)