How to Optimize Kubernetes Costs for OpenClaw

# Get resource requests for all OpenClaw pods:
kubectl get pods -A -o jsonpath='{range .items[*]}{.metadata.namespace}{"\t"}{.metadata.name}{"\t"}{.spec.containers[*].resources}{"\n"}{end}' | grep openclaw

# Or use kubectl describe for detailed view:
kubectl describe pod -n openclaw <pod-name>

# Check actual usage vs requested:
kubectl top pods -n openclaw

# Example output:
# NAME                    CPU(cores)  MEMORY(Mi)
# openclaw-api-5d4f2      50m         128Mi      # Requests 500m/512Mi - 90% wasted!
# openclaw-worker-abc123  200m        256Mi      # Requests 1000m/1Gi - 80% wasted!

# Calculate waste across all pods:
kubectl get pods -A -o jsonpath='{range .items[*]}{.spec.containers[*].resources.requests.cpu}{"\n"}{end}' | grep -o '[0-9]*m' | awk '{sum+=$1} END {print "Total CPU requested: "sum" millicores"}'

# 1. Run for 1-2 weeks with current requests
# 2. Monitor actual usage with kubectl top
# 3. Update resource requests to ~120% of observed peak usage

# Example: API pod uses max 200m CPU, 256Mi memory
# New requests: 250m CPU, 300Mi memory
# New limits: 500m CPU, 600Mi memory (2x requests for burst headroom)

# Update deployment:
# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: openclaw-api
  namespace: openclaw
spec:
  template:
    spec:
      containers:
      - name: openclaw
        resources:
          requests:
            cpu: 250m         # Down from 500m
            memory: 300Mi     # Down from 512Mi
          limits:
            cpu: 500m         # Allow bursts
            memory: 600Mi

# Apply changes:
kubectl apply -f deployment.yaml

# hpa.yaml
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: openclaw-api-hpa
  namespace: openclaw
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: openclaw-api
  minReplicas: 1          # Minimum pods (don't go to zero)
  maxReplicas: 10         # Maximum pods to avoid runaway costs
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70      # Scale up at 70% CPU
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 80      # Scale up at 80% memory
  behavior:
    scaleDown:
      stabilizationWindowSeconds: 300  # Wait 5min before scaling down
      policies:
      - type: Percent
        value: 50                      # Remove up to 50% of pods per window
    scaleUp:
      stabilizationWindowSeconds: 0    # Scale up immediately
      policies:
      - type: Percent
        value: 100                     # Can double pods per window

# Apply:
kubectl apply -f hpa.yaml

# Monitor autoscaling:
kubectl get hpa -n openclaw -w

# Example: AWS EKS with Spot instances
# In your node group configuration:

# eksctl configuration (spot-nodegroup.yaml):
apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig
metadata:
  name: openclaw-cluster
nodeGroups:
  - name: on-demand
    minSize: 1
    maxSize: 3
    instanceTypes: ["t3.medium"]  # On-demand for critical workloads
    desiredCapacity: 2

  - name: spot
    minSize: 0
    maxSize: 10
    instanceTypes: ["t3.medium", "t3a.medium", "t2.medium"]  # Multiple types for better availability
    spot: true                     # Use spot instances
    desiredCapacity: 2

# Deploy OpenClaw API (critical) on on-demand:
# deployment-api.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: openclaw-api
spec:
  template:
    spec:
      nodeSelector:
        karpenter.sh/capacity-type: on-demand

# Deploy OpenClaw workers (non-critical) on spot:
# deployment-worker.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: openclaw-worker
spec:
  template:
    spec:
      nodeSelector:
        karpenter.sh/capacity-type: spot
      # Pod disruption budget allows graceful shutdown
      terminationGracePeriodSeconds: 30

# Cost: Spot instances are 60-90% cheaper than on-demand
# For a 3-node on-demand cluster ($0.096/hour each) vs spot ($0.029/hour):
# Monthly savings: 3 nodes × 730 hours × ($0.096 - $0.029) = ~$147/month

# List current storage classes:
kubectl get storageclass

# Create economy storage class:
# storage-class.yaml
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: openclaw-economy
provisioner: ebs.csi.aws.com
parameters:
  type: gp3              # General purpose (cheaper than gp2)
  iops: "3000"           # Minimum IOPS for gp3
  throughput: "125"      # Baseline throughput
  encrypted: "true"
reclaimPolicy: Delete    # Delete volumes when PVC deleted
allowVolumeExpansion: true

# PVC using economy storage:
# pvc.yaml
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: openclaw-logs
  namespace: openclaw
spec:
  accessModes:
    - ReadWriteOnce
  storageClassName: openclaw-economy
  resources:
    requests:
      storage: 50Gi      # Right-size based on needs

# Implement log cleanup:
# cleanup-cronjob.yaml
apiVersion: batch/v1
kind: CronJob
metadata:
  name: openclaw-log-cleanup
  namespace: openclaw
spec:
  schedule: "0 2 * * *"  # 2am daily
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: cleanup
            image: ubuntu:22.04
            command:
            - /bin/bash
            - -c
            - |
              find /var/log/openclaw -type f -mtime +30 -delete  # Delete logs older than 30 days
            volumeMounts:
            - name: logs
              mountPath: /var/log/openclaw
          volumes:
          - name: logs
            persistentVolumeClaim:
              claimName: openclaw-logs
          restartPolicy: OnFailure

# ResourceQuota limits namespace-wide resources:
# quota.yaml
apiVersion: v1
kind: ResourceQuota
metadata:
  name: openclaw-quota
  namespace: openclaw
spec:
  hard:
    requests.cpu: "10"           # Max 10 CPU cores in namespace
    requests.memory: "20Gi"      # Max 20GB memory in namespace
    limits.cpu: "20"             # Hard limit
    limits.memory: "40Gi"
    pods: "50"                   # Max 50 pods
    persistentvolumeclaims: "10"

# LimitRange sets defaults for individual pods:
# limitrange.yaml
apiVersion: v1
kind: LimitRange
metadata:
  name: openclaw-limits
  namespace: openclaw
spec:
  limits:
  - type: Container
    min:
      cpu: 50m
      memory: 64Mi
    max:
      cpu: 2
      memory: 4Gi
    default:
      cpu: 500m
      memory: 512Mi
    defaultRequest:
      cpu: 100m
      memory: 128Mi

# Apply:
kubectl apply -f quota.yaml limitrange.yaml

# View quota usage:
kubectl describe resourcequota openclaw-quota -n openclaw

# Install Kubecost (cost monitoring tool):
helm repo add kubecost https://kubecost.github.io/cost-analyzer/
helm install kubecost kubecost/cost-analyzer \
  --namespace kubecost --create-namespace \
  --values values.yaml

# Access Kubecost dashboard:
kubectl port-forward -n kubecost svc/kubecost-cost-analyzer 9090:9090
# Open http://localhost:9090

# Example insights from Kubecost:
# - OpenClaw API: $250/month (25% of cluster)
# - OpenClaw workers: $400/month (40% of cluster)
# - Storage: $100/month (10% of cluster)
# - Idle resources: $250/month (25% wasted!)

# Set up Prometheus alerts for high costs:
# prometheus-rules.yaml
apiVersion: monitoring.coreos.com/v1
kind: PrometheusRule
metadata:
  name: kubernetes-cost-alerts
spec:
  groups:
  - name: kubecost.rules
    rules:
    - alert: HighClusterCost
      expr: kubecost_cluster_cost > 5000  # Alert if cluster costs > $5000/month
      for: 1h
      annotations:
        summary: "Cluster costs unusually high"

    - alert: HighIdleResources
      expr: kubecost_idle_cpu_allocation > 0.5  # Alert if > 50% CPU idle
      for: 4h
      annotations:
        summary: "Significant idle resources detected"