How AWS Graviton4 ARM Processors Optimize Kubernetes 1.32 Node Performance for Go 1.24 Apps

// node-readiness-checker.go
// Go 1.24 DaemonSet for validating Graviton4 + K8s 1.32 node compatibility
// Compile: GOOS=linux GOARCH=arm64 go build -o node-readiness-checker main.go
package main

import (
    "bufio"
    "context"
    "flag"
    "fmt"
    "log"
    "net/http"
    "os"
    "os/signal"
    "runtime"
    "strconv"
    "strings"
    "syscall"
    "time"
)

var (
    nodeName      = flag.String("node-name", "", "Kubernetes node name (from env NODE_NAME)")
    kubeletPort   = flag.Int("kubelet-port", 10250, "Kubelet read-only port")
    metricsPort   = flag.Int("metrics-port", 8080, "Metrics HTTP port")
    checkInterval = flag.Duration("check-interval", 30*time.Second, "Node check interval")
)

// graviton4CPUPart is the Arm Neoverse V2 part number used in Graviton4
const graviton4CPUPart = "0xd4f"

// checkGraviton4 validates the node runs on AWS Graviton4 ARM64 processor
func checkGraviton4() (bool, error) {
    // Read /proc/cpuinfo to extract CPU part number
    file, err := os.Open("/proc/cpuinfo")
    if err != nil {
        return false, fmt.Errorf("failed to open /proc/cpuinfo: %w", err)
    }
    defer file.Close()

    scanner := bufio.NewScanner(file)
    for scanner.Scan() {
        line := strings.TrimSpace(scanner.Text())
        if strings.HasPrefix(line, "CPU part") {
            parts := strings.Split(line, ":")
            if len(parts) != 2 {
                continue
            }
            cpuPart := strings.TrimSpace(parts[1])
            if cpuPart == graviton4CPUPart {
                log.Printf("Detected Graviton4 CPU (Neoverse V2, part %s)", cpuPart)
                return true, nil
            }
        }
    }

    if err := scanner.Err(); err != nil {
        return false, fmt.Errorf("failed to scan /proc/cpuinfo: %w", err)
    }
    return false, nil
}

// checkK8sVersion validates kubelet version is >= 1.32
func checkK8sVersion() (bool, error) {
    // Call kubelet /version endpoint
    url := fmt.Sprintf("http://localhost:%d/version", *kubeletPort)
    resp, err := http.Get(url)
    if err != nil {
        return false, fmt.Errorf("failed to call kubelet /version: %w", err)
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return false, fmt.Errorf("kubelet /version returned status %d", resp.StatusCode)
    }

    // Parse version from response (simplified for example; real impl uses JSON)
    // K8s 1.32 kubelet returns version in header or body, here we check major.minor
    // For brevity, assume we extract major=1, minor=32
    major, minor := 1, 32 // Simplified for compileable example
    if major < 1 || (major == 1 && minor < 32) {
        return false, fmt.Errorf("kubelet version %d.%d < 1.32", major, minor)
    }
    log.Printf("Kubelet version 1.32+ detected")
    return true, nil
}

// metricsHandler exposes readiness metrics via HTTP
func metricsHandler(w http.ResponseWriter, r *http.Request) {
    gravitonOk, gravitonErr := checkGraviton4()
    k8sOk, k8sErr := checkK8sVersion()

    w.Header().Set("Content-Type", "text/plain")
    fmt.Fprintf(w, "node_readiness_status{check=\"graviton4\"} %d\n", boolToInt(gravitonOk))
    fmt.Fprintf(w, "node_readiness_status{check=\"k8s_version\"} %d\n", boolToInt(k8sOk))
    fmt.Fprintf(w, "node_readiness_errors{check=\"graviton4\"} %d\n", boolToInt(gravitonErr != nil))
    fmt.Fprintf(w, "node_readiness_errors{check=\"k8s_version\"} %d\n", boolToInt(k8sErr != nil))
    fmt.Fprintf(w, "node_go_version_info{version=\"%s\"} 1\n", runtime.Version())
}

func boolToInt(b bool) int {
    if b {
        return 1
    }
    return 0
}

func main() {
    flag.Parse()
    if *nodeName == "" {
        *nodeName = os.Getenv("NODE_NAME")
        if *nodeName == "" {
            log.Fatal("node-name flag or NODE_NAME env must be set")
        }
    }

    log.Printf("Starting node readiness checker for node %s", *nodeName)
    log.Printf("Go version: %s", runtime.Version())
    log.Printf("GOMAXPROCS: %d", runtime.GOMAXPROCS(0))

    // Initial check
    gravitonOk, gravitonErr := checkGraviton4()
    k8sOk, k8sErr := checkK8sVersion()
    log.Printf("Initial checks: Graviton4=%v (err=%v), K8s 1.32+=%v (err=%v)", gravitonOk, gravitonErr, k8sOk, k8sErr)

    // Start metrics server
    http.HandleFunc("/metrics", metricsHandler)
    http.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
        if gravitonOk && k8sOk {
            w.WriteHeader(http.StatusOK)
            fmt.Fprint(w, "ok")
        } else {
            w.WriteHeader(http.StatusServiceUnavailable)
            fmt.Fprint(w, "not ready")
        }
    })

    go func() {
        log.Printf("Metrics server listening on :%d", *metricsPort)
        if err := http.ListenAndServe(fmt.Sprintf(":%d", *metricsPort), nil); err != nil {
            log.Fatalf("Metrics server failed: %v", err)
        }
    }()

    // Periodic recheck
    ticker := time.NewTicker(*checkInterval)
    defer ticker.Stop()
    sigChan := make(chan os.Signal, 1)
    signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)

    for {
        select {
        case <-ticker.C:
            gravitonOk, gravitonErr = checkGraviton4()
            k8sOk, k8sErr = checkK8sVersion()
            log.Printf("Periodic check: Graviton4=%v, K8s 1.32+=%v", gravitonOk, k8sOk)
        case sig := <-sigChan:
            log.Printf("Received signal %s, shutting down", sig)
            return
        }
    }
}

// graviton4-bench.go
// Go 1.24 benchmark comparing HTTP performance on Graviton4 vs x86 nodes
// Run on Graviton4: go run graviton4-bench.go --mode server --port 8080
// Run client: go run graviton4-bench.go --mode client --target http://graviton4-node:8080 --duration 60s
package main

import (
    "bytes"
    "context"
    "crypto/tls"
    "flag"
    "fmt"
    "io"
    "log"
    "math/rand"
    "net/http"
    "os"
    "os/signal"
    "runtime"
    "sync"
    "sync/atomic"
    "syscall"
    "time"
)

var (
    mode       = flag.String("mode", "server", "Run mode: server or client")
    port       = flag.Int("port", 8080, "Server listen port")
    target     = flag.String("target", "http://localhost:8080", "Client target URL")
    duration   = flag.Duration("duration", 60*time.Second, "Client benchmark duration")
    conns      = flag.Int("conns", 100, "Client concurrent connections")
    payloadSize = flag.Int("payload-size", 1024, "Request payload size in bytes")
    useTLS     = flag.Bool("use-tls", false, "Use TLS for server/client")
)

// serverHandler handles benchmark requests, returns random payload
func serverHandler(w http.ResponseWriter, r *http.Request) {
    // Go 1.24 optimized ARM64 crypto for random bytes generation
    payload := make([]byte, *payloadSize)
    rand.Read(payload) // Uses ARM64-optimized AES-CTR in Go 1.24 on Graviton4
    w.Header().Set("Content-Type", "application/octet-stream")
    w.Write(payload)
}

func runServer() {
    mux := http.NewServeMux()
    mux.HandleFunc("/bench", serverHandler)
    mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusOK)
    })

    var srv *http.Server
    if *useTLS {
        // Generate self-signed cert for testing (simplified)
        cert, err := generateSelfSignedCert()
        if err != nil {
            log.Fatalf("Failed to generate TLS cert: %v", err)
        }
        srv = &http.Server{
            Addr:    fmt.Sprintf(":%d", *port),
            Handler: mux,
            TLSConfig: &tls.Config{
                Certificates: []tls.Certificate{cert},
            },
        }
        log.Printf("Starting TLS server on :%d", *port)
        go func() {
            if err := srv.ListenAndServeTLS("", ""); err != nil && err != http.ErrServerClosed {
                log.Fatalf("TLS server failed: %v", err)
            }
        }()
    } else {
        srv = &http.Server{
            Addr:    fmt.Sprintf(":%d", *port),
            Handler: mux,
        }
        log.Printf("Starting HTTP server on :%d", *port)
        go func() {
            if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
                log.Fatalf("HTTP server failed: %v", err)
            }
        }()
    }

    // Wait for shutdown signal
    sigChan := make(chan os.Signal, 1)
    signal.Notify(sigChan, os.Interrupt, syscall.SIGTERM)
    <-sigChan
    log.Println("Shutting down server...")
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()
    if err := srv.Shutdown(ctx); err != nil {
        log.Fatalf("Server shutdown failed: %v", err)
    }
}

// generateSelfSignedCert generates a self-signed cert for testing (simplified)
func generateSelfSignedCert() (tls.Certificate, error) {
    // In real code, use crypto/tls and crypto/x509; simplified here for brevity
    return tls.Certificate{}, nil
}

type benchResult struct {
    totalReqs   uint64
    successReqs uint64
    totalLatNs  uint64
    minLatNs    uint64
    maxLatNs    uint64
}

func runClient() {
    log.Printf("Starting benchmark client: target=%s, duration=%s, conns=%d, payload=%d bytes",
        *target, *duration, *conns, *payloadSize)

    payload := make([]byte, *payloadSize)
    rand.Read(payload)

    var result benchResult
    result.minLatNs = ^uint64(0) // Max uint64

    var wg sync.WaitGroup
    stopChan := make(chan struct{})

    // Start concurrent workers
    for i := 0; i < *conns; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            client := &http.Client{
                Timeout: 10 * time.Second,
                Transport: &http.Transport{
                    // Go 1.24 optimized ARM64 TLS handshake in Transport
                    TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
                },
            }
            for {
                select {
                case <-stopChan:
                    return
                default:
                    start := time.Now()
                    resp, err := client.Post(*target+"/bench", "application/octet-stream", bytes.NewReader(payload))
                    lat := time.Since(start).Nanoseconds()
                    atomic.AddUint64(&result.totalReqs, 1)
                    atomic.AddUint64(&result.totalLatNs, uint64(lat))

                    if lat < atomic.LoadUint64(&result.minLatNs) {
                        atomic.StoreUint64(&result.minLatNs, uint64(lat))
                    }
                    if lat > atomic.LoadUint64(&result.maxLatNs) {
                        atomic.StoreUint64(&result.maxLatNs, uint64(lat))
                    }

                    if err != nil {
                        log.Printf("Request failed: %v", err)
                        continue
                    }
                    atomic.AddUint64(&result.successReqs, 1)
                    io.Copy(io.Discard, resp.Body)
                    resp.Body.Close()
                }
            }
        }()
    }

    // Run benchmark for specified duration
    time.Sleep(*duration)
    close(stopChan)
    wg.Wait()

    // Calculate results
    totalReqs := atomic.LoadUint64(&result.totalReqs)
    successReqs := atomic.LoadUint64(&result.successReqs)
    avgLatMs := float64(atomic.LoadUint64(&result.totalLatNs)) / float64(totalReqs) / 1e6
    minLatMs := float64(atomic.LoadUint64(&result.minLatNs)) / 1e6
    maxLatMs := float64(atomic.LoadUint64(&result.maxLatNs)) / 1e6
    throughput := float64(totalReqs) / (*duration).Seconds()

    log.Println("=== Benchmark Results ===")
    log.Printf("Total requests: %d", totalReqs)
    log.Printf("Successful requests: %d (%.2f%%)", successReqs, float64(successReqs)/float64(totalReqs)*100)
    log.Printf("Average latency: %.2f ms", avgLatMs)
    log.Printf("Min latency: %.2f ms", minLatMs)
    log.Printf("Max latency: %.2f ms", maxLatMs)
    log.Printf("Throughput: %.2f req/s", throughput)
    log.Printf("Go version: %s", runtime.Version())
    log.Printf("GOMAXPROCS: %d", runtime.GOMAXPROCS(0))
}

func main() {
    flag.Parse()
    runtime.GOMAXPROCS(runtime.NumCPU()) // Go 1.24 scheduler optimizes for Graviton4 Neoverse V2 core count
    log.Printf("Go version: %s", runtime.Version())
    log.Printf("Running on %s/%s", runtime.GOOS, runtime.GOARCH)

    switch *mode {
    case "server":
        runServer()
    case "client":
        runClient()
    default:
        log.Fatalf("Invalid mode: %s. Use 'server' or 'client'", *mode)
    }
}

// graviton4-app-config.go
// Go 1.24 application configurator for Graviton4 nodes: optimizes runtime parameters
// Reads K8s downward API, detects Graviton4, sets optimal GOMAXPROCS, GOGC, GODEBUG
// Compile: GOOS=linux GOARCH=arm64 go build -o app-config main.go
package main

import (
    "bufio"
    "context"
    "fmt"
    "log"
    "os"
    "path/filepath"
    "runtime"
    "strconv"
    "strings"
    "time"
)

const (
    // Graviton4 Neoverse V2 has 2MB L2 cache per core, 64-byte cache lines
    graviton4L2CachePerCore = 2 * 1024 * 1024 // 2MB
    graviton4CacheLineSize  = 64
    // K8s downward API paths
    podCpuLimitPath = "/sys/fs/cgroup/cpu/cpu.cfs_quota_us" // Pre-1.25 cgroup v1, adjust for v2
    podCpuPeriodPath = "/sys/fs/cgroup/cpu/cpu.cfs_period_us"
    nodeNamePath     = "/etc/podinfo/node-name" // Mounted via downward API
    cpuInfoPath      = "/proc/cpuinfo"
)

// detectGraviton4 checks if the node is running AWS Graviton4
func detectGraviton4() bool {
    file, err := os.Open(cpuInfoPath)
    if err != nil {
        log.Printf("Failed to open %s: %v", cpuInfoPath, err)
        return false
    }
    defer file.Close()

    scanner := bufio.NewScanner(file)
    for scanner.Scan() {
        line := strings.TrimSpace(scanner.Text())
        if strings.HasPrefix(line, "CPU part") {
            parts := strings.Split(line, ":")
            if len(parts) != 2 {
                continue
            }
            cpuPart := strings.TrimSpace(parts[1])
            // Neoverse V2 part number for Graviton4
            if cpuPart == "0xd4f" {
                return true
            }
        }
    }
    if err := scanner.Err(); err != nil {
        log.Printf("Failed to scan %s: %v", cpuInfoPath, err)
    }
    return false
}

// getPodCPULimit reads K8s pod CPU limit from cgroup
func getPodCPULimit() (int, error) {
    quotaBytes, err := os.ReadFile(podCpuLimitPath)
    if err != nil {
        return 0, fmt.Errorf("failed to read %s: %w", podCpuLimitPath, err)
    }
    quotaStr := strings.TrimSpace(string(quotaBytes))
    quota, err := strconv.Atoi(quotaStr)
    if err != nil {
        return 0, fmt.Errorf("failed to parse CPU quota %s: %w", quotaStr, err)
    }

    periodBytes, err := os.ReadFile(podCpuPeriodPath)
    if err != nil {
        return 0, fmt.Errorf("failed to read %s: %w", podCpuPeriodPath, err)
    }
    periodStr := strings.TrimSpace(string(periodBytes))
    period, err := strconv.Atoi(periodStr)
    if err != nil {
        return 0, fmt.Errorf("failed to parse CPU period %s: %w", periodStr, err)
    }

    // CPU limit = quota / period, in cores
    if period == 0 {
        return 0, fmt.Errorf("CPU period is 0")
    }
    cpuLimit := quota / period
    if cpuLimit <= 0 {
        // No limit set, use node CPU count
        return runtime.NumCPU(), nil
    }
    return cpuLimit, nil
}

// setGraviton4Optimizations sets Go runtime parameters optimal for Graviton4
func setGraviton4Optimizations(cpuLimit int) {
    // Go 1.24 scheduler is optimized for Neoverse V2's 8-wide decode, set GOMAXPROCS to CPU limit
    runtime.GOMAXPROCS(cpuLimit)
    log.Printf("Set GOMAXPROCS to %d", cpuLimit)

    // Graviton4 has large L2 cache, reduce GC frequency by setting GOGC to 200 (default 100)
    // Go 1.24's GC has ARM64-optimized write barriers, so higher GOGC is safe
    os.Setenv("GOGC", "200")
    log.Printf("Set GOGC to 200 (default 100)")

    // Enable Go 1.24's new ARM64-specific scheduler pinning for low latency
    os.Setenv("GODEBUG", "schedarm64pin=1")
    log.Printf("Enabled ARM64 scheduler pinning via GODEBUG=schedarm64pin=1")

    // Set GODEBUG for Graviton4's AES instructions (Go 1.24 uses AES-CTR for crypto/random)
    os.Setenv("GODEBUG", os.Getenv("GODEBUG")+",arm64aes=1")
    log.Printf("Enabled ARM64 AES instructions via GODEBUG=arm64aes=1")
}

// setDefaultOptimizations sets standard optimizations for non-Graviton4 nodes
func setDefaultOptimizations(cpuLimit int) {
    runtime.GOMAXPROCS(cpuLimit)
    log.Printf("Set GOMAXPROCS to %d (default)", cpuLimit)
    os.Setenv("GOGC", "100")
    log.Printf("Set GOGC to 100 (default)")
}

func main() {
    log.Printf("Starting Graviton4 app configurator")
    log.Printf("Go version: %s", runtime.Version())
    log.Printf("Initial GOMAXPROCS: %d", runtime.GOMAXPROCS(0))

    // Read pod CPU limit from cgroup
    cpuLimit, err := getPodCPULimit()
    if err != nil {
        log.Printf("Failed to read CPU limit: %v. Using node CPU count (%d)", err, runtime.NumCPU())
        cpuLimit = runtime.NumCPU()
    }
    log.Printf("Pod CPU limit: %d cores", cpuLimit)

    // Detect if running on Graviton4
    isGraviton4 := detectGraviton4()
    if isGraviton4 {
        log.Println("Detected AWS Graviton4 (Neoverse V2). Applying optimizations.")
        setGraviton4Optimizations(cpuLimit)
    } else {
        log.Println("Non-Graviton4 node detected. Applying default optimizations.")
        setDefaultOptimizations(cpuLimit)
    }

    // Read node name from downward API
    nodeName := "unknown"
    if nodeBytes, err := os.ReadFile(nodeNamePath); err == nil {
        nodeName = strings.TrimSpace(string(nodeBytes))
    }
    log.Printf("Running on node: %s", nodeName)

    // Keep running to allow runtime parameters to take effect
    log.Println("Configurator complete. Waiting for app to exit...")
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()
    // In real app, this would start the main application; here we wait
    <-ctx.Done()
}

apiVersion: kubelet.config.k8s.io/v1beta1
kind: KubeletConfiguration
cpuManagerPolicy: static
cpuManagerReconcilePeriod: 5s
reservedSystemCPUs: "0-1"
featureGates:
  CPUManagerPolicyOptions: true
cpuManagerPolicyOptions:
  - "full-pcpus-only=true"

env:
  - name: GODEBUG
    value: "schedarm64pin=1,arm64aes=1"
  - name: GOGC
    value: "200"
  - name: GOMAXPROCS
    valueFrom:
      resourceFieldRef:
        resource: limits.cpu

apiVersion: karpenter.sh/v1beta1
kind: Provisioner
metadata:
  name: graviton4
 spec:
  requirements:
    - key: kubernetes.io/arch
      operator: In
      values: ["arm64"]
    - key: node.kubernetes.io/instance-type
      operator: In
      values: ["m7g.4xlarge", "m7g.8xlarge"]
  limits:
    resources:
      cpu: "1000"
      memory: "4000Gi"
  provider:
    subnetSelector:
      karpenter.sh/discovery: "my-cluster"
    securityGroupSelector:
      karpenter.sh/discovery: "my-cluster"