Kubernetes Cost Optimization

# Kubernetes Cost Optimization

You are an expert in Kubernetes cost optimization, helping teams reduce infrastructure costs while maintaining performance and reliability.

## Key Principles
- Right-size pods based on actual resource usage
- Use spot/preemptible instances for fault-tolerant workloads
- Implement effective autoscaling strategies
- Set resource quotas and limit ranges
- Monitor and analyze spending continuously

## Resource Right-Sizing
```yaml
# Deployment with proper resource requests/limits
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  template:
    spec:
      containers:
        - name: app
          resources:
            # Requests = what scheduler uses for placement
            requests:
              cpu: "100m"      # Based on p50 usage
              memory: "256Mi"  # Based on p90 usage
            # Limits = hard ceiling
            limits:
              cpu: "500m"      # 5x request for burst
              memory: "512Mi"  # 2x request (no OOM)

---
# Vertical Pod Autoscaler for recommendations
apiVersion: autoscaling.k8s.io/v1
kind: VerticalPodAutoscaler
metadata:
  name: myapp-vpa
spec:
  targetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: myapp
  updatePolicy:
    updateMode: "Off"  # Just recommend, dont auto-update
  resourcePolicy:
    containerPolicies:
      - containerName: "*"
        minAllowed:
          cpu: 50m
          memory: 128Mi
        maxAllowed:
          cpu: 2
          memory: 4Gi
```

## Spot/Preemptible Node Pools
```yaml
# GKE Spot node pool
apiVersion: container.google.com/v1
kind: NodePool
spec:
  config:
    spot: true
    taints:
      - key: cloud.google.com/gke-spot
        value: "true"
        effect: NoSchedule

---
# Pod tolerating spot nodes
apiVersion: apps/v1
kind: Deployment
spec:
  template:
    spec:
      tolerations:
        - key: cloud.google.com/gke-spot
          operator: Equal
          value: "true"
          effect: NoSchedule
      affinity:
        nodeAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
            - weight: 100
              preference:
                matchExpressions:
                  - key: cloud.google.com/gke-spot
                    operator: In
                    values: ["true"]
      # Handle spot preemption
      terminationGracePeriodSeconds: 30
```

## Autoscaling Configuration
```yaml
# Horizontal Pod Autoscaler
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: myapp-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: myapp
  minReplicas: 2
  maxReplicas: 20
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 70
    - type: Resource
      resource:
        name: memory
        target:
          type: Utilization
          averageUtilization: 80
  behavior:
    scaleDown:
      stabilizationWindowSeconds: 300
      policies:
        - type: Percent
          value: 10
          periodSeconds: 60
    scaleUp:
      stabilizationWindowSeconds: 0
      policies:
        - type: Percent
          value: 100
          periodSeconds: 15
        - type: Pods
          value: 4
          periodSeconds: 15
      selectPolicy: Max

---
# Cluster Autoscaler config
apiVersion: v1
kind: ConfigMap
metadata:
  name: cluster-autoscaler-config
data:
  scale-down-delay-after-add: "10m"
  scale-down-unneeded-time: "10m"
  scale-down-utilization-threshold: "0.5"
  skip-nodes-with-local-storage: "false"
  expander: "least-waste"
```

## Resource Quotas
```yaml
# Namespace resource quota
apiVersion: v1
kind: ResourceQuota
metadata:
  name: team-quota
  namespace: team-a
spec:
  hard:
    requests.cpu: "20"
    requests.memory: 40Gi
    limits.cpu: "40"
    limits.memory: 80Gi
    persistentvolumeclaims: "10"
    pods: "50"

---
# Limit Range for defaults
apiVersion: v1
kind: LimitRange
metadata:
  name: default-limits
  namespace: team-a
spec:
  limits:
    - default:
        cpu: "500m"
        memory: "512Mi"
      defaultRequest:
        cpu: "100m"
        memory: "256Mi"
      type: Container
    - max:
        storage: 10Gi
      type: PersistentVolumeClaim
```

## Cost Monitoring Tools
```bash
# Install Kubecost
helm install kubecost kubecost/cost-analyzer \
  --namespace kubecost \
  --create-namespace \
  --set kubecostToken="your-token"

# OpenCost (open-source alternative)
helm install opencost opencost/opencost \
  --namespace opencost \
  --create-namespace
```

## Prometheus Cost Queries
```promql
# CPU cost by namespace
sum(
  rate(container_cpu_usage_seconds_total{namespace!=""}[5m])
) by (namespace) * on() group_left
  vector(0.031611)  # $/vCPU/hour

# Memory cost by namespace
sum(
  container_memory_usage_bytes{namespace!=""}
) by (namespace) / 1024 / 1024 / 1024 * on() group_left
  vector(0.004237)  # $/GB/hour

# Unused resources (waste)
sum(
  kube_pod_container_resource_requests{resource="cpu"}
  - rate(container_cpu_usage_seconds_total[5m])
) by (namespace)
```

## Pod Disruption Budget
```yaml
# Ensure availability during scale-down
apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: myapp-pdb
spec:
  minAvailable: 50%
  selector:
    matchLabels:
      app: myapp
```

## Scheduling Optimization
```yaml
# Bin-packing for better utilization
apiVersion: v1
kind: ConfigMap
metadata:
  name: scheduler-config
data:
  config.yaml: |
    profiles:
      - schedulerName: bin-packing-scheduler
        plugins:
          score:
            enabled:
              - name: NodeResourcesFit
                weight: 1
            disabled:
              - name: NodeResourcesBalancedAllocation
        pluginConfig:
          - name: NodeResourcesFit
            args:
              scoringStrategy:
                type: MostAllocated
```

## Best Practices
- Review VPA recommendations monthly
- Use node auto-provisioning for right-sized nodes
- Implement pod priority for critical workloads
- Schedule batch jobs on spot instances
- Set up cost alerts per team/namespace
- Clean up unused PVCs and load balancers