How to Set Up Horizontal Pod Autoscaling with Metrics Server 0.7 and KEDA 2.14

package main

import (
    "fmt"
    "os"
    "os/exec"
    "runtime"
    "strings"
)

// requiredTools lists all CLIs required for the tutorial
var requiredTools = []string{"docker", "kind", "kubectl", "helm", "go"}

// checkTool verifies if a CLI is installed and returns its version
func checkTool(tool string) (string, error) {
    cmd := exec.Command(tool, "--version")
    if tool == "kubectl" {
        cmd = exec.Command(tool, "version", "--client", "--short")
    }
    if tool == "helm" {
        cmd = exec.Command(tool, "version", "--short")
    }
    output, err := cmd.Output()
    if err != nil {
        return "", fmt.Errorf("failed to run %s --version: %w", tool, err)
    }
    // Trim trailing newline and extract first line for version
    version := strings.Split(strings.TrimSpace(string(output)), "\n")[0]
    return version, nil
}

func main() {
    fmt.Println("🔍 Validating tutorial prerequisites...")
    var missing []string
    for _, tool := range requiredTools {
        version, err := checkTool(tool)
        if err != nil {
            missing = append(missing, tool)
            fmt.Printf("❌ %s: not installed\n", tool)
            continue
        }
        fmt.Printf("✅ %s: %s\n", tool, version)
    }

    if len(missing) > 0 {
        fmt.Printf("\n❌ Missing required tools: %v\n", missing)
        fmt.Println("Install missing tools before proceeding:")
        fmt.Println("- Docker: https://docs.docker.com/engine/install/")
        fmt.Println("- Kind: https://kind.sigs.k8s.io/docs/user/quick-start/")
        fmt.Println("- kubectl: https://kubernetes.io/docs/tasks/tools/")
        fmt.Println("- Helm: https://helm.sh/docs/intro/install/")
        fmt.Println("- Go: https://go.dev/doc/install")
        os.Exit(1)
    }

    // Verify OS compatibility (kind requires Linux or macOS, or Windows with WSL2)
    osName := runtime.GOOS
    if osName != "linux" && osName != "darwin" {
        fmt.Printf("⚠️ Detected OS: %s. Kind works best on Linux/macOS, or Windows with WSL2.\n", osName)
    }

    fmt.Println("\n✅ All prerequisites satisfied. Proceeding with cluster setup.")
}

package main

import (
    "context"
    "fmt"
    "os"
    "os/exec"
    "strings"
    "time"

    "k8s.io/client-go/kubernetes"
    "k8s.io/client-go/tools/clientcmd"
    "k8s.io/apimachinery/pkg/util/wait"
    corev1 "k8s.io/api/core/v1"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

const (
    clusterName = "hpa-tutorial-cluster"
    kindConfig  = `kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
- role: control-plane
  kubeadmConfigPatches:
  - |
    kind: InitConfiguration
    nodeRegistration:
      kubeletExtraArgs:
        node-labels: "ingress-ready=true"
  extraPortMappings:
  - containerPort: 80
    hostPort: 8080
    protocol: TCP
  - containerPort: 443
    hostPort: 8443
    protocol: TCP
- role: worker
- role: worker
`
)

// createKindCluster creates a kind cluster with the predefined config
func createKindCluster() error {
    // Check if cluster already exists
    cmd := exec.Command("kind", "get", "clusters")
    output, err := cmd.Output()
    if err != nil {
        return fmt.Errorf("failed to list kind clusters: %w", err)
    }
    if strings.Contains(string(output), clusterName) {
        fmt.Printf("⚠️ Cluster %s already exists. Deleting and recreating...\n", clusterName)
        deleteCmd := exec.Command("kind", "delete", "cluster", "--name", clusterName)
        if err := deleteCmd.Run(); err != nil {
            return fmt.Errorf("failed to delete existing cluster: %w", err)
        }
    }

    // Write kind config to temporary file
    configFile, err := os.CreateTemp("", "kind-config-*.yaml")
    if err != nil {
        return fmt.Errorf("failed to create temp config file: %w", err)
    }
    defer os.Remove(configFile.Name())

    if _, err := configFile.WriteString(kindConfig); err != nil {
        return fmt.Errorf("failed to write kind config: %w", err)
    }
    if err := configFile.Close(); err != nil {
        return fmt.Errorf("failed to close config file: %w", err)
    }

    // Create cluster
    createCmd := exec.Command("kind", "create", "cluster", "--name", clusterName, "--config", configFile.Name())
    createCmd.Stdout = os.Stdout
    createCmd.Stderr = os.Stderr
    if err := createCmd.Run(); err != nil {
        return fmt.Errorf("failed to create kind cluster: %w", err)
    }

    return nil
}

// waitForClusterReady waits for all nodes to be Ready
func waitForClusterReady() error {
    kubeconfig := os.Getenv("KUBECONFIG")
    if kubeconfig == "" {
        kubeconfig = os.Getenv("HOME") + "/.kube/config"
    }
    config, err := clientcmd.BuildConfigFromFlags("", kubeconfig)
    if err != nil {
        return fmt.Errorf("failed to load kubeconfig: %w", err)
    }
    clientset, err := kubernetes.NewForConfig(config)
    if err != nil {
        return fmt.Errorf("failed to create kubernetes client: %w", err)
    }

    ctx := context.Background()
    fmt.Println("⏳ Waiting for all nodes to be Ready...")
    err = wait.PollUntilContextTimeout(ctx, 5*time.Second, 2*time.Minute, true, func(ctx context.Context) (bool, error) {
        nodes, err := clientset.CoreV1().Nodes().List(ctx, metav1.ListOptions{})
        if err != nil {
            return false, err
        }
        for _, node := range nodes.Items {
            for _, cond := range node.Status.Conditions {
                if cond.Type == corev1.NodeReady && cond.Status != corev1.ConditionTrue {
                    return false, nil
                }
            }
        }
        return true, nil
    })
    if err != nil {
        return fmt.Errorf("cluster did not become ready in time: %w", err)
    }

    fmt.Println("✅ All nodes are Ready.")
    return nil
}

func main() {
    fmt.Println("🚀 Creating kind cluster for HPA tutorial...")
    if err := createKindCluster(); err != nil {
        fmt.Printf("❌ Failed to create cluster: %v\n", err)
        os.Exit(1)
    }

    if err := waitForClusterReady(); err != nil {
        fmt.Printf("❌ Cluster readiness check failed: %v\n", err)
        os.Exit(1)
    }

    fmt.Println("🎉 Kind cluster is ready. Proceeding with Metrics Server installation.")
}

package main

import (
    "context"
    "fmt"
    "os"
    "os/exec"
    "time"

    "k8s.io/client-go/kubernetes"
    "k8s.io/client-go/tools/clientcmd"
    "k8s.io/apimachinery/pkg/util/wait"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

const (
    metricsServerNamespace = "kube-system"
    metricsServerVersion   = "v0.7.0"
    metricsServerURL       = "https://github.com/kubernetes-sigs/metrics-server/releases/download/" + metricsServerVersion + "/components.yaml"
)

// installMetricsServer deploys Metrics Server 0.7 via kubectl apply
func installMetricsServer() error {
    cmd := exec.Command("kubectl", "apply", "-f", metricsServerURL)
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr
    if err := cmd.Run(); err != nil {
        return fmt.Errorf("failed to apply Metrics Server manifest: %w", err)
    }

    // Patch Metrics Server to allow insecure TLS (required for kind)
    patchCmd := exec.Command("kubectl", "patch", "deployment", "metrics-server", "-n", metricsServerNamespace,
        "--type=json", "-p", `[{"op":"add","path":"/spec/template/spec/containers/0/args/-","value":"--kubelet-insecure-tls"}]`)
    if err := patchCmd.Run(); err != nil {
        return fmt.Errorf("failed to patch Metrics Server for insecure TLS: %w", err)
    }

    fmt.Println("✅ Metrics Server 0.7 manifest applied and patched for kind.")
    return nil
}

// verifyMetricsServer checks if Metrics Server pods are running and metrics are available
func verifyMetricsServer() error {
    kubeconfig := os.Getenv("KUBECONFIG")
    if kubeconfig == "" {
        kubeconfig = os.Getenv("HOME") + "/.kube/config"
    }
    config, err := clientcmd.BuildConfigFromFlags("", kubeconfig)
    if err != nil {
        return fmt.Errorf("failed to load kubeconfig: %w", err)
    }
    clientset, err := kubernetes.NewForConfig(config)
    if err != nil {
        return fmt.Errorf("failed to create kubernetes client: %w", err)
    }

    ctx := context.Background()
    // Wait for Metrics Server pod to be Running
    fmt.Println("⏳ Waiting for Metrics Server pod to be Running...")
    err = wait.PollUntilContextTimeout(ctx, 5*time.Second, 2*time.Minute, true, func(ctx context.Context) (bool, error) {
        pods, err := clientset.CoreV1().Pods(metricsServerNamespace).List(ctx, metav1.ListOptions{
            LabelSelector: "k8s-app=metrics-server",
        })
        if err != nil {
            return false, err
        }
        if len(pods.Items) == 0 {
            return false, nil
        }
        for _, pod := range pods.Items {
            if pod.Status.Phase != corev1.PodRunning {
                return false, nil
            }
        }
        return true, nil
    })
    if err != nil {
        return fmt.Errorf("Metrics Server pod did not start: %w", err)
    }

    // Check if metrics are available
    fmt.Println("⏳ Verifying metrics are being scraped...")
    err = wait.PollUntilContextTimeout(ctx, 10*time.Second, 3*time.Minute, true, func(ctx context.Context) (bool, error) {
        cmd := exec.Command("kubectl", "get", "--raw", "/apis/metrics.k8s.io/v1beta1/pods")
        output, err := cmd.Output()
        if err != nil {
            return false, nil
        }
        if len(output) > 0 {
            return true, nil
        }
        return false, nil
    })
    if err != nil {
        return fmt.Errorf("Metrics Server is not serving metrics: %w", err)
    }

    fmt.Println("✅ Metrics Server 0.7 is running and serving metrics.")
    return nil
}

func main() {
    fmt.Println("📊 Installing Metrics Server 0.7...")
    if err := installMetricsServer(); err != nil {
        fmt.Printf("❌ Installation failed: %v\n", err)
        os.Exit(1)
    }

    if err := verifyMetricsServer(); err != nil {
        fmt.Printf("❌ Verification failed: %v\n", err)
        os.Exit(1)
    }

    fmt.Println("🎉 Metrics Server setup complete. Proceeding with KEDA 2.14 installation.")
}

package main

import (
    "context"
    "fmt"
    "os"
    "os/exec"
    "time"

    "k8s.io/client-go/kubernetes"
    "k8s.io/client-go/tools/clientcmd"
    "k8s.io/apimachinery/pkg/util/wait"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

const (
    kedaNamespace    = "keda"
    kedaVersion      = "2.14.0"
    kedaHelmRepo     = "https://kedacore.github.io/charts"
    kedaHelmChart    = "kedacore/keda"
)

// addKedaHelmRepo adds the KEDA Helm repository
func addKedaHelmRepo() error {
    cmd := exec.Command("helm", "repo", "add", "kedacore", kedaHelmRepo)
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr
    if err := cmd.Run(); err != nil {
        return fmt.Errorf("failed to add KEDA Helm repo: %w", err)
    }

    updateCmd := exec.Command("helm", "repo", "update")
    updateCmd.Stdout = os.Stdout
    updateCmd.Stderr = os.Stderr
    if err := updateCmd.Run(); err != nil {
        return fmt.Errorf("failed to update Helm repos: %w", err)
    }

    fmt.Println("✅ KEDA Helm repository added and updated.")
    return nil
}

// installKeda installs KEDA 2.14 via Helm
func installKeda() error {
    cmd := exec.Command("helm", "install", "keda", kedaHelmChart,
        "--namespace", kedaNamespace,
        "--create-namespace",
        "--version", kedaVersion,
        "--set", "image.tag=v"+kedaVersion,
        "--set", "metricsServer.image.tag=v"+kedaVersion,
    )
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr
    if err := cmd.Run(); err != nil {
        return fmt.Errorf("failed to install KEDA: %w", err)
    }

    fmt.Println("✅ KEDA 2.14 installed via Helm.")
    return nil
}

// verifyKeda checks if KEDA operator pods are running
func verifyKeda() error {
    kubeconfig := os.Getenv("KUBECONFIG")
    if kubeconfig == "" {
        kubeconfig = os.Getenv("HOME") + "/.kube/config"
    }
    config, err := clientcmd.BuildConfigFromFlags("", kubeconfig)
    if err != nil {
        return fmt.Errorf("failed to load kubeconfig: %w", err)
    }
    clientset, err := kubernetes.NewForConfig(config)
    if err != nil {
        return fmt.Errorf("failed to create kubernetes client: %w", err)
    }

    ctx := context.Background()
    fmt.Println("⏳ Waiting for KEDA operator pods to be Running...")
    err = wait.PollUntilContextTimeout(ctx, 5*time.Second, 2*time.Minute, true, func(ctx context.Context) (bool, error) {
        pods, err := clientset.CoreV1().Pods(kedaNamespace).List(ctx, metav1.ListOptions{
            LabelSelector: "app=keda-operator",
        })
        if err != nil {
            return false, err
        }
        if len(pods.Items) == 0 {
            return false, nil
        }
        for _, pod := range pods.Items {
            if pod.Status.Phase != corev1.PodRunning {
                return false, nil
            }
        }
        return true, nil
    })
    if err != nil {
        return fmt.Errorf("KEDA operator pod did not start: %w", err)
    }

    // Check KEDA CRDs are installed
    cmd := exec.Command("kubectl", "get", "crd", "scaledobjects.keda.sh")
    if err := cmd.Run(); err != nil {
        return fmt.Errorf("KEDA CRDs not installed: %w", err)
    }

    fmt.Println("✅ KEDA 2.14 is running and CRDs are available.")
    return nil
}

func main() {
    fmt.Println("🚀 Installing KEDA 2.14...")
    if err := addKedaHelmRepo(); err != nil {
        fmt.Printf("❌ Failed to add Helm repo: %v\n", err)
        os.Exit(1)
    }

    if err := installKeda(); err != nil {
        fmt.Printf("❌ Failed to install KEDA: %v\n", err)
        os.Exit(1)
    }

    if err := verifyKeda(); err != nil {
        fmt.Printf("❌ Verification failed: %v\n", err)
        os.Exit(1)
    }

    fmt.Println("🎉 KEDA setup complete. Proceeding with sample app deployment.")
}

kubectl patch deployment metrics-server -n kube-system --type=json -p '[{"op":"add","path":"/spec/template/spec/containers/0/resources","value":{"requests":{"cpu":"50m","memory":"30Mi"},"limits":{"cpu":"100m","memory":"60Mi"}}}]'

apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: kafka-worker-scaler
spec:
  scaleTargetRef:
    name: redis-worker
  minReplicaCount: 0
  maxReplicaCount: 20
  triggers:
  - type: kafka
    metadata:
      bootstrapServers: kafka:9092
      consumerGroup: order-workers
      topic: order-events
      lagThreshold: "10"

kubectl patch deployment metrics-server -n kube-system --type=json -p '[{"op":"add","path":"/spec/template/spec/containers/0/args/-","value":"--v=2"}]'

helm upgrade keda kedacore/keda --namespace keda --set logLevel=debug

hpa-metrics-keda-guide/
├── cmd/
│   ├── prereq-check/
│   │   └── main.go          # Prerequisite validation tool
│   ├── cluster-setup/
│   │   └── main.go          # Kind cluster creation tool
│   ├── metrics-server/
│   │   └── main.go          # Metrics Server installer
│   └── keda/
│       └── main.go          # KEDA installer
├── deploy/
│   ├── metrics-server/      # Metrics Server manifests
│   ├── keda/                # KEDA Helm values
│   └── sample-apps/
│       ├── nginx/           # Sample Nginx HPA config
│       └── redis-worker/    # Sample Redis worker KEDA config
├── helm/
│   └── hpa-tutorial/        # Helm chart for full stack deployment
├── docs/
│   └── benchmarks/          # Benchmark results and raw data
└── README.md                # Tutorial instructions and setup guide