Implement Kubernetes workload rightsizing with VPA recommendations and cost analysis

#!/usr/bin/env bash
set -euo pipefail

# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color

# Default values
CLUSTER_NAME="${1:-k8s-cluster}"
PROMETHEUS_RETENTION="${2:-15d}"
GRAFANA_PASSWORD="${3:-AdminPassword123!}"

# Usage function
usage() {
    echo "Usage: $0 [cluster-name] [prometheus-retention] [grafana-password]"
    echo "Example: $0 my-cluster 30d MySecurePassword123"
    exit 1
}

# Logging functions
log_info() { echo -e "${GREEN}[INFO]${NC} $1"; }
log_warn() { echo -e "${YELLOW}[WARN]${NC} $1"; }
log_error() { echo -e "${RED}[ERROR]${NC} $1"; }

# Cleanup function
cleanup() {
    log_error "Script failed. Check logs above for details."
    # Remove temp files if they exist
    rm -f /tmp/prometheus-values.yaml /tmp/grafana-values.yaml /tmp/webapp-vpa.yaml 2>/dev/null || true
}
trap cleanup ERR

# Check if running as root or with sudo
check_privileges() {
    if [[ $EUID -eq 0 ]]; then
        log_warn "Running as root. Consider using a non-root user with sudo for kubectl operations."
    elif ! sudo -n true 2>/dev/null; then
        log_error "This script requires sudo privileges for package installation"
        exit 1
    fi
}

# Detect Linux distribution
detect_distro() {
    if [ -f /etc/os-release ]; then
        . /etc/os-release
        case "$ID" in
            ubuntu|debian) 
                PKG_MGR="apt"
                PKG_INSTALL="apt install -y"
                PKG_UPDATE="apt update"
                ;;
            almalinux|rocky|centos|rhel|ol|fedora) 
                PKG_MGR="dnf"
                PKG_INSTALL="dnf install -y"
                PKG_UPDATE="dnf check-update || true"
                ;;
            amzn) 
                PKG_MGR="yum"
                PKG_INSTALL="yum install -y"
                PKG_UPDATE="yum check-update || true"
                ;;
            *) 
                log_error "Unsupported distribution: $ID"
                exit 1
                ;;
        esac
        log_info "Detected distribution: $ID ($VERSION_ID)"
    else
        log_error "Cannot detect Linux distribution"
        exit 1
    fi
}

# Install prerequisites
install_prerequisites() {
    echo "[1/8] Installing prerequisites..."
    
    # Update package manager
    if [[ $EUID -eq 0 ]]; then
        $PKG_UPDATE
    else
        sudo $PKG_UPDATE
    fi
    
    # Install common packages
    local packages="curl wget git"
    
    if [[ $EUID -eq 0 ]]; then
        $PKG_INSTALL $packages
    else
        sudo $PKG_INSTALL $packages
    fi
    
    log_info "Prerequisites installed successfully"
}

# Install kubectl
install_kubectl() {
    echo "[2/8] Installing kubectl..."
    
    if command -v kubectl &> /dev/null; then
        log_info "kubectl already installed: $(kubectl version --client --short 2>/dev/null || kubectl version --client)"
        return
    fi
    
    curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
    chmod 755 kubectl
    
    if [[ $EUID -eq 0 ]]; then
        mv kubectl /usr/local/bin/
    else
        sudo mv kubectl /usr/local/bin/
    fi
    
    log_info "kubectl installed successfully"
}

# Install Helm
install_helm() {
    echo "[3/8] Installing Helm..."
    
    if command -v helm &> /dev/null; then
        log_info "Helm already installed: $(helm version --short)"
        return
    fi
    
    curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash
    log_info "Helm installed successfully"
}

# Install metrics-server
install_metrics_server() {
    echo "[4/8] Installing metrics-server..."
    
    # Check if metrics-server is already running
    if kubectl get pods -n kube-system | grep metrics-server | grep Running &>/dev/null; then
        log_info "metrics-server already running"
        return
    fi
    
    kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml
    
    # Wait for metrics-server to be ready
    log_info "Waiting for metrics-server to be ready..."
    kubectl wait --for=condition=ready pod -l k8s-app=metrics-server -n kube-system --timeout=300s
    
    log_info "metrics-server installed and ready"
}

# Install VPA
install_vpa() {
    echo "[5/8] Installing Vertical Pod Autoscaler..."
    
    # Check if VPA CRDs already exist
    if kubectl get crd | grep verticalpodautoscaler &>/dev/null; then
        log_info "VPA already installed"
        return
    fi
    
    # Clone VPA repository
    local temp_dir="/tmp/autoscaler-$$"
    git clone https://github.com/kubernetes/autoscaler.git "$temp_dir"
    cd "$temp_dir/vertical-pod-autoscaler"
    
    # Install VPA
    ./hack/vpa-install.sh
    
    # Wait for VPA components to be ready
    log_info "Waiting for VPA components to be ready..."
    kubectl wait --for=condition=ready pod -l app=vpa-admission-controller -n kube-system --timeout=300s
    kubectl wait --for=condition=ready pod -l app=vpa-recommender -n kube-system --timeout=300s
    kubectl wait --for=condition=ready pod -l app=vpa-updater -n kube-system --timeout=300s
    
    # Cleanup
    cd /
    rm -rf "$temp_dir"
    
    log_info "VPA installed successfully"
}

# Install Prometheus
install_prometheus() {
    echo "[6/8] Installing Prometheus..."
    
    # Create monitoring namespace
    kubectl create namespace monitoring --dry-run=client -o yaml | kubectl apply -f -
    
    # Add Prometheus Helm repository
    helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
    helm repo update
    
    # Create Prometheus values file
    cat > /tmp/prometheus-values.yaml << EOF
server:
  retention: "$PROMETHEUS_RETENTION"
  resources:
    requests:
      cpu: 200m
      memory: 512Mi
    limits:
      cpu: 500m
      memory: 1Gi
  persistentVolume:
    size: 20Gi

nodeExporter:
  enabled: true

kubeStateMetrics:
  enabled: true

alertmanager:
  enabled: false

pushgateway:
  enabled: false
EOF
    
    # Install Prometheus
    if helm list -n monitoring | grep prometheus &>/dev/null; then
        log_info "Prometheus already installed, upgrading..."
        helm upgrade prometheus prometheus-community/prometheus \
            --namespace monitoring \
            --values /tmp/prometheus-values.yaml
    else
        helm install prometheus prometheus-community/prometheus \
            --namespace monitoring \
            --values /tmp/prometheus-values.yaml
    fi
    
    # Wait for Prometheus to be ready
    log_info "Waiting for Prometheus to be ready..."
    kubectl wait --for=condition=ready pod -l app.kubernetes.io/name=prometheus,app.kubernetes.io/component=server -n monitoring --timeout=300s
    
    rm -f /tmp/prometheus-values.yaml
    log_info "Prometheus installed successfully"
}

# Install Grafana
install_grafana() {
    echo "[7/8] Installing Grafana..."
    
    # Add Grafana Helm repository
    helm repo add grafana https://grafana.github.io/helm-charts
    helm repo update
    
    # Create Grafana values file
    cat > /tmp/grafana-values.yaml << EOF
adminPassword: "$GRAFANA_PASSWORD"

persistence:
  enabled: true
  size: 10Gi

service:
  type: ClusterIP
  port: 80

datasources:
  datasources.yaml:
    apiVersion: 1
    datasources:
    - name: Prometheus
      type: prometheus
      url: http://prometheus-server.monitoring.svc.cluster.local
      access: proxy
      isDefault: true

resources:
  requests:
    cpu: 100m
    memory: 256Mi
  limits:
    cpu: 500m
    memory: 512Mi
EOF
    
    # Install Grafana
    if helm list -n monitoring | grep grafana &>/dev/null; then
        log_info "Grafana already installed, upgrading..."
        helm upgrade grafana grafana/grafana \
            --namespace monitoring \
            --values /tmp/grafana-values.yaml
    else
        helm install grafana grafana/grafana \
            --namespace monitoring \
            --values /tmp/grafana-values.yaml
    fi
    
    # Wait for Grafana to be ready
    log_info "Waiting for Grafana to be ready..."
    kubectl wait --for=condition=ready pod -l app.kubernetes.io/name=grafana -n monitoring --timeout=300s
    
    rm -f /tmp/grafana-values.yaml
    log_info "Grafana installed successfully"
}

# Configure sample VPA
configure_sample_vpa() {
    echo "[8/8] Configuring sample VPA..."
    
    # Create sample webapp with VPA
    cat > /tmp/webapp-vpa.yaml << EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  name: webapp
  namespace: default
spec:
  replicas: 2
  selector:
    matchLabels:
      app: webapp
  template:
    metadata:
      labels:
        app: webapp
    spec:
      containers:
      - name: webapp
        image: nginx:1.21
        resources:
          requests:
            cpu: 50m
            memory: 64Mi
          limits:
            cpu: 200m
            memory: 256Mi
        ports:
        - containerPort: 80
---
apiVersion: autoscaling.k8s.io/v1
kind: VerticalPodAutoscaler
metadata:
  name: webapp-vpa
  namespace: default
spec:
  targetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: webapp
  updatePolicy:
    updateMode: "Off"
  resourcePolicy:
    containerPolicies:
    - containerName: webapp
      minAllowed:
        cpu: 10m
        memory: 64Mi
      maxAllowed:
        cpu: 1000m
        memory: 2Gi
      controlledResources: ["cpu", "memory"]
EOF
    
    kubectl apply -f /tmp/webapp-vpa.yaml
    rm -f /tmp/webapp-vpa.yaml
    
    log_info "Sample webapp with VPA configured"
}

# Verify installation
verify_installation() {
    echo
    log_info "=== Installation Verification ==="
    
    # Check metrics-server
    if kubectl get pods -n kube-system | grep metrics-server | grep Running &>/dev/null; then
        log_info "✓ metrics-server is running"
    else
        log_error "✗ metrics-server is not running"
    fi
    
    # Check VPA components
    if kubectl get crd | grep verticalpodautoscaler &>/dev/null; then
        log_info "✓ VPA CRDs are installed"
    else
        log_error "✗ VPA CRDs are missing"
    fi
    
    # Check Prometheus
    if kubectl get pods -n monitoring | grep prometheus-server | grep Running &>/dev/null; then
        log_info "✓ Prometheus is running"
    else
        log_error "✗ Prometheus is not running"
    fi
    
    # Check Grafana
    if kubectl get pods -n monitoring | grep grafana | grep Running &>/dev/null; then
        log_info "✓ Grafana is running"
        echo
        log_info "Grafana admin password: $GRAFANA_PASSWORD"
        log_info "Access Grafana with: kubectl port-forward -n monitoring svc/grafana 3000:80"
    else
        log_error "✗ Grafana is not running"
    fi
    
    # Check sample VPA
    if kubectl get vpa webapp-vpa &>/dev/null; then
        log_info "✓ Sample VPA is configured"
        echo
        log_info "View VPA recommendations with: kubectl describe vpa webapp-vpa"
    else
        log_error "✗ Sample VPA is not configured"
    fi
    
    echo
    log_info "Installation completed! Wait a few minutes for VPA to generate recommendations."
}

# Main execution
main() {
    log_info "Starting Kubernetes VPA and Cost Analysis installation..."
    
    check_privileges
    detect_distro
    
    # Validate kubectl connectivity
    if ! kubectl cluster-info &>/dev/null; then
        log_error "Cannot connect to Kubernetes cluster. Please ensure kubectl is configured."
        exit 1
    fi
    
    install_prerequisites
    install_kubectl
    install_helm
    install_metrics_server
    install_vpa
    install_prometheus
    install_grafana
    configure_sample_vpa
    verify_installation
    
    log_info "All components installed successfully!"
}

# Validate arguments
if [[ $# -gt 3 ]]; then
    usage
fi

main "$@"