<div id="readability-page-1" class="page"><div><img src="https://devstarsj.github.io/assets/https://images.unsplash.com/photo-1667372393119-3d4c48d07fc9?w=1200"><h2 id="kubernetes-cost-optimization-10-strategies-to-cut-your-cloud-bill-in-half">Kubernetes Cost Optimization: 10 Strategies to Cut Your Cloud Bill in Half</h2>Running Kubernetes in production is expensive. The average enterprise wastes 35-45% of their cloud budget on over-provisioned resources. Here’s how to stop the bleeding.<img src="https://images.unsplash.com/photo-1667372393119-3d4c48d07fc9?w=800" alt="Cloud Infrastructure"> Photo by <a href="https://unsplash.com/@growtika">Growtika</a> on UnsplashBefore diving into solutions, let’s understand the problem:<ul><li>Over-provisioning: Developers request 4 CPU cores, use 0.5</li><li>Zombie workloads: Forgotten deployments running 24/7</li><li>Wrong instance types: Using compute-optimized for memory-heavy apps</li><li>No autoscaling: Fixed replicas regardless of traffic</li></ul>A typical 100-node cluster can easily waste $50,000-100,000/month.<h2 id="strategy-1-right-size-your-pods">Strategy 1: Right-Size Your Pods</h2>The biggest waste comes from incorrect resource requests and limits.<h3 id="analyze-current-usage">Analyze Current Usage</h3><div><pre><code># Install metrics-server if not present
kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml

# Check actual vs requested resources
kubectl top pods --all-namespaces
</code></pre></div><h3 id="use-vertical-pod-autoscaler-vpa">Use Vertical Pod Autoscaler (VPA)</h3><div><pre><code>apiVersion: autoscaling.k8s.io/v1
kind: VerticalPodAutoscaler
metadata:
 name: my-app-vpa
spec:
 targetRef:
 apiVersion: apps/v1
 kind: Deployment
 name: my-app
 updatePolicy:
 updateMode: "Auto"
 resourcePolicy:
 containerPolicies:
 - containerName: '*'
 minAllowed:
 cpu: 100m
 memory: 128Mi
 maxAllowed:
 cpu: 4
 memory: 8Gi
</code></pre></div>Impact: Typically reduces resource waste by 40-60%.<h2 id="strategy-2-implement-cluster-autoscaler">Strategy 2: Implement Cluster Autoscaler</h2>Stop paying for idle nodes.<div><pre><code>apiVersion: apps/v1
kind: Deployment
metadata:
 name: cluster-autoscaler
 namespace: kube-system
spec:
 replicas: 1
 selector:
 matchLabels:
 app: cluster-autoscaler
 template:
 spec:
 containers:
 - name: cluster-autoscaler
 image: k8s.gcr.io/autoscaling/cluster-autoscaler:v1.28.0
 command:
 - ./cluster-autoscaler
 - --cloud-provider=aws
 - --scale-down-delay-after-add=10m
 - --scale-down-unneeded-time=5m
 - --skip-nodes-with-local-storage=false
</code></pre></div><h3 id="key-settings">Key Settings</h3><table><thead><tr><th>Parameter</th><th>Recommended</th><th>Why</th></tr></thead><tbody><tr><td>scale-down-delay-after-add</td><td>10m</td><td>Prevent thrashing</td></tr><tr><td>scale-down-unneeded-time</td><td>5m</td><td>Quick response</td></tr><tr><td>max-node-provision-time</td><td>15m</td><td>Fail fast</td></tr></tbody></table><img src="https://images.unsplash.com/photo-1558494949-ef010cbdcc31?w=800" alt="Server Room"> Photo by <a href="https://unsplash.com/@tvick">Taylor Vick</a> on Unsplash<h2 id="strategy-3-use-spotpreemptible-instances">Strategy 3: Use Spot/Preemptible Instances</h2>Spot instances cost 60-90% less than on-demand.<h3 id="aws-spot-with-karpenter">AWS Spot with Karpenter</h3><div><pre><code>apiVersion: karpenter.sh/v1alpha5
kind: Provisioner
metadata:
 name: spot-provisioner
spec:
 requirements:
 - key: karpenter.sh/capacity-type
 operator: In
 values: ["spot", "on-demand"]
 - key: kubernetes.io/arch
 operator: In
 values: ["amd64", "arm64"]
 limits:
 resources:
 cpu: 1000
 providerRef:
 name: default
 ttlSecondsAfterEmpty: 30
</code></pre></div><h3 id="best-practices-for-spot">Best Practices for Spot</h3><ol><li>Diversify instance types — Use multiple families (m5, m6i, c5, c6i)</li><li>Handle interruptions gracefully — Use PodDisruptionBudgets</li><li>Keep stateful workloads on-demand — Databases, message queues</li><li>Use spot for batch jobs — CI/CD, data processing</li></ol><h2 id="strategy-4-namespace-resource-quotas">Strategy 4: Namespace Resource Quotas</h2>Prevent runaway resource consumption.<div><pre><code>apiVersion: v1
kind: ResourceQuota
metadata:
 name: team-budget
 namespace: team-alpha
spec:
 hard:
 requests.cpu: "20"
 requests.memory: 40Gi
 limits.cpu: "40"
 limits.memory: 80Gi
 pods: "50"
 services: "10"
 persistentvolumeclaims: "20"
</code></pre></div><h2 id="strategy-5-implement-pod-priority-and-preemption">Strategy 5: Implement Pod Priority and Preemption</h2>Let critical workloads survive during resource contention.<div><pre><code>apiVersion: scheduling.k8s.io/v1
kind: PriorityClass
metadata:
 name: high-priority
value: 1000000
globalDefault: false
description: "Critical production workloads"
---
apiVersion: scheduling.k8s.io/v1
kind: PriorityClass
metadata:
 name: low-priority
value: 100
globalDefault: true
description: "Development and batch jobs"
</code></pre></div><h2 id="strategy-6-right-size-your-nodes">Strategy 6: Right-Size Your Nodes</h2>Node selection matters more than you think.<h3 id="instance-type-comparison">Instance Type Comparison</h3><table><thead><tr><th>Workload Type</th><th>Recommended Instance</th><th>Why</th></tr></thead><tbody><tr><td>General apps</td><td>m6i.xlarge</td><td>Balanced CPU/memory</td></tr><tr><td>Memory-heavy</td><td>r6i.xlarge</td><td>8:1 memory ratio</td></tr><tr><td>Compute-heavy</td><td>c6i.xlarge</td><td>High CPU clock</td></tr><tr><td>ML inference</td><td>g5.xlarge</td><td>Cost-effective GPU</td></tr><tr><td>Batch jobs</td><td>m6i.large (spot)</td><td>Cheap and disposable</td></tr></tbody></table><h3 id="arm64-can-save-20-40">ARM64 Can Save 20-40%</h3><div><pre><code>spec:
 nodeSelector:
 kubernetes.io/arch: arm64
</code></pre></div>Graviton3 instances offer better price-performance for many workloads.<h2 id="strategy-7-scheduled-scaling">Strategy 7: Scheduled Scaling</h2>Development environments don’t need to run 24/7.<div><pre><code>apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
 name: dev-scaler
spec:
 scaleTargetRef:
 name: dev-deployment
 minReplicaCount: 0
 maxReplicaCount: 5
 triggers:
 - type: cron
 metadata:
 timezone: America/New_York
 start: 0 8 * * 1-5 # 8 AM weekdays
 end: 0 20 * * 1-5 # 8 PM weekdays
 desiredReplicas: "3"
</code></pre></div>Savings: 60%+ for non-production environments.<h2 id="strategy-8-storage-optimization">Strategy 8: Storage Optimization</h2>PersistentVolumes can silently drain your budget.<h3 id="use-appropriate-storage-classes">Use Appropriate Storage Classes</h3><div><pre><code>apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
 name: cold-storage
provisioner: ebs.csi.aws.com
parameters:
 type: sc1 # Cold HDD - $0.015/GB vs $0.10/GB for gp3
 fsType: ext4
reclaimPolicy: Delete
volumeBindingMode: WaitForFirstConsumer
</code></pre></div><h3 id="storage-tier-guidelines">Storage Tier Guidelines</h3><table><thead><tr><th>Use Case</th><th>AWS</th><th>GCP</th><th>Azure</th></tr></thead><tbody><tr><td>Databases</td><td>gp3</td><td>pd-ssd</td><td>Premium SSD</td></tr><tr><td>Logs/Archives</td><td>sc1</td><td>pd-standard</td><td>Standard HDD</td></tr><tr><td>Scratch/Temp</td><td>Instance store</td><td>Local SSD</td><td>Temp disk</td></tr></tbody></table><h2 id="strategy-9-network-cost-reduction">Strategy 9: Network Cost Reduction</h2>Cross-AZ traffic adds up quickly.<h3 id="keep-traffic-local">Keep Traffic Local</h3><div><pre><code>apiVersion: v1
kind: Service
metadata:
 name: my-service
 annotations:
 service.kubernetes.io/topology-aware-hints: auto
spec:
 topologyKeys:
 - "topology.kubernetes.io/zone"
 - "*"
</code></pre></div><h3 id="use-internal-load-balancers">Use Internal Load Balancers</h3>External ALBs cost more. Use internal where possible:<div><pre><code>metadata:
 annotations:
 service.beta.kubernetes.io/aws-load-balancer-internal: "true"
</code></pre></div><h2 id="strategy-10-implement-finops-practices">Strategy 10: Implement FinOps Practices</h2>Make cost visibility part of your culture.<h3 id="essential-tools">Essential Tools</h3><ol><li>Kubecost — Real-time cost allocation</li><li>OpenCost — CNCF open-source alternative</li><li>Kubernetes Resource Report — Lightweight usage reports</li><li>Cloud provider tools — AWS Cost Explorer, GCP Billing</li></ol><h3 id="cost-allocation-labels">Cost Allocation Labels</h3><div><pre><code>metadata:
 labels:
 app: my-app
 team: platform
 environment: production
 cost-center: eng-123
</code></pre></div><h2 id="quick-wins-checklist">Quick Wins Checklist</h2><table><thead><tr><th>Action</th><th>Effort</th><th>Savings</th></tr></thead><tbody><tr><td>Right-size pods with VPA</td><td>Medium</td><td>30-50%</td></tr><tr><td>Enable cluster autoscaler</td><td>Low</td><td>20-40%</td></tr><tr><td>Use spot for stateless</td><td>Medium</td><td>60-70%</td></tr><tr><td>Schedule dev environments</td><td>Low</td><td>60%+</td></tr><tr><td>Switch to ARM64</td><td>Medium</td><td>20-40%</td></tr><tr><td>Optimize storage classes</td><td>Low</td><td>30-50%</td></tr></tbody></table><h2 id="measuring-success">Measuring Success</h2>Track these metrics weekly:<ol><li>Cost per pod-hour — Should decrease over time</li><li>Resource utilization — Target 60-70%</li><li>Spot instance percentage — Aim for 50%+ of compute</li><li>Idle resource hours — Should trend toward zero</li></ol><h2 id="conclusion">Conclusion</h2>Kubernetes cost optimization isn’t a one-time project — it’s an ongoing practice. Start with the quick wins (autoscaling, spot instances), then build toward a FinOps culture where every team understands their infrastructure costs.The best part? These optimizations often improve performance too. Right-sized pods schedule faster, and autoscaling handles traffic spikes better than fixed capacity.Start today: Install Kubecost, review your top 10 most expensive workloads, and right-size them. You’ll likely find 30%+ savings in your first week.<hr>What’s your Kubernetes cost optimization strategy? The cloud bill never lies. <div>이 글이 도움이 되셨다면 공감 및 광고 클릭을 부탁드립니다 :) </div></div></div>

Dev Note

Kubernetes Cost Optimization: 10 Strategies to Cut Your Cloud Bill in Half
Running Kubernetes in production is expensive. The average enterprise wastes 35-45% of their cloud budget on over-provisioned resources. Here’s how to stop the bleeding.
Photo by Growtika on Unsplash
The Hidden Cost of Kubernetes
Before diving into solutions, let’s understand the problem:
Over-provisioning: Developers request 4 CPU cores, use 0.5
Zombie workloads: Forgotten deployments running 24/7
Wrong instance types: Using compute-optimized for memory-heavy apps
No autoscaling: Fixed replicas regardless of traffic
A typical 100-node cluster can easily waste $50,000-100,000/month.
Strategy 1: Right-Size Your Pods
The biggest waste comes from incorrect resource requests and limits.
Analyze Current Usage
# Install metrics-server if not present
kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml
# Check actual vs requested resources
kubectl top pods --all-namespaces
Use Vertical Pod Autoscaler (VPA)
apiVersion: autoscaling.k8s.io/v1
kind: VerticalPodAutoscaler
metadata:
  name: my-app-vpa
spec:
  targetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: my-app
  updatePolicy:
    updateMode: "Auto"
  resourcePolicy:
    containerPolicies:
    - containerName: '*'
      minAllowed:
        cpu: 100m
        memory: 128Mi
      maxAllowed:
        cpu: 4
        memory: 8Gi
Impact: Typically reduces resource waste by 40-60%.
Strategy 2: Implement Cluster Autoscaler
Stop paying for idle nodes.
apiVersion: apps/v1
kind: Deployment
metadata:
  name: cluster-autoscaler
  namespace: kube-system
spec:
  replicas: 1
  selector:
    matchLabels:
      app: cluster-autoscaler
  template:
    spec:
      containers:
      - name: cluster-autoscaler
        image: k8s.gcr.io/autoscaling/cluster-autoscaler:v1.28.0
        command:
        - ./cluster-autoscaler
        - --cloud-provider=aws
        - --scale-down-delay-after-add=10m
        - --scale-down-unneeded-time=5m
        - --skip-nodes-with-local-storage=false
Key Settings
Parameter
      Recommended
      Why
    
scale-down-delay-after-add
      10m
      Prevent thrashing
    
scale-down-unneeded-time
      5m
      Quick response
    
max-node-provision-time
      15m
      Fail fast
    
Photo by Taylor Vick on Unsplash
Strategy 3: Use Spot/Preemptible Instances
Spot instances cost 60-90% less than on-demand.
AWS Spot with Karpenter
apiVersion: karpenter.sh/v1alpha5
kind: Provisioner
metadata:
  name: spot-provisioner
spec:
  requirements:
  - key: karpenter.sh/capacity-type
    operator: In
    values: ["spot", "on-demand"]
  - key: kubernetes.io/arch
    operator: In
    values: ["amd64", "arm64"]
  limits:
    resources:
      cpu: 1000
  providerRef:
    name: default
  ttlSecondsAfterEmpty: 30
Best Practices for Spot
Diversify instance types — Use multiple families (m5, m6i, c5, c6i)
Handle interruptions gracefully — Use PodDisruptionBudgets
Keep stateful workloads on-demand — Databases, message queues
Use spot for batch jobs — CI/CD, data processing
Strategy 4: Namespace Resource Quotas
Prevent runaway resource consumption.
apiVersion: v1
kind: ResourceQuota
metadata:
  name: team-budget
  namespace: team-alpha
spec:
  hard:
    requests.cpu: "20"
    requests.memory: 40Gi
    limits.cpu: "40"
    limits.memory: 80Gi
    pods: "50"
    services: "10"
    persistentvolumeclaims: "20"
Strategy 5: Implement Pod Priority and Preemption
Let critical workloads survive during resource contention.
apiVersion: scheduling.k8s.io/v1
kind: PriorityClass
metadata:
  name: high-priority
value: 1000000
globalDefault: false
description: "Critical production workloads"
---
apiVersion: scheduling.k8s.io/v1
kind: PriorityClass
metadata:
  name: low-priority
value: 100
globalDefault: true
description: "Development and batch jobs"
Strategy 6: Right-Size Your Nodes
Node selection matters more than you think.
Instance Type Comparison
Workload Type
      Recommended Instance
      Why
    
General apps
      m6i.xlarge
      Balanced CPU/memory
    
Memory-heavy
      r6i.xlarge
      8:1 memory ratio
    
Compute-heavy
      c6i.xlarge
      High CPU clock
    
ML inference
      g5.xlarge
      Cost-effective GPU
    
Batch jobs
      m6i.large (spot)
      Cheap and disposable
    
ARM64 Can Save 20-40%
spec:
  nodeSelector:
    kubernetes.io/arch: arm64
Graviton3 instances offer better price-performance for many workloads.
Strategy 7: Scheduled Scaling
Development environments don’t need to run 24/7.
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: dev-scaler
spec:
  scaleTargetRef:
    name: dev-deployment
  minReplicaCount: 0
  maxReplicaCount: 5
  triggers:
  - type: cron
    metadata:
      timezone: America/New_York
      start: 0 8 * * 1-5  # 8 AM weekdays
      end: 0 20 * * 1-5   # 8 PM weekdays
      desiredReplicas: "3"
Savings: 60%+ for non-production environments.
Strategy 8: Storage Optimization
PersistentVolumes can silently drain your budget.
Use Appropriate Storage Classes
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: cold-storage
provisioner: ebs.csi.aws.com
parameters:
  type: sc1  # Cold HDD - $0.015/GB vs $0.10/GB for gp3
  fsType: ext4
reclaimPolicy: Delete
volumeBindingMode: WaitForFirstConsumer
Storage Tier Guidelines
Use Case
      AWS
      GCP
      Azure
    
Databases
      gp3
      pd-ssd
      Premium SSD
    
Logs/Archives
      sc1
      pd-standard
      Standard HDD
    
Scratch/Temp
      Instance store
      Local SSD
      Temp disk
    
Strategy 9: Network Cost Reduction
Cross-AZ traffic adds up quickly.
Keep Traffic Local
apiVersion: v1
kind: Service
metadata:
  name: my-service
  annotations:
    service.kubernetes.io/topology-aware-hints: auto
spec:
  topologyKeys:
  - "topology.kubernetes.io/zone"
  - "*"
Use Internal Load Balancers
External ALBs cost more. Use internal where possible:
metadata:
  annotations:
    service.beta.kubernetes.io/aws-load-balancer-internal: "true"
Strategy 10: Implement FinOps Practices
Make cost visibility part of your culture.
Essential Tools
Kubecost — Real-time cost allocation
OpenCost — CNCF open-source alternative
Kubernetes Resource Report — Lightweight usage reports
Cloud provider tools — AWS Cost Explorer, GCP Billing
Cost Allocation Labels
metadata:
  labels:
    app: my-app
    team: platform
    environment: production
    cost-center: eng-123
Quick Wins Checklist
Action
      Effort
      Savings
    
Right-size pods with VPA
      Medium
      30-50%
    
Enable cluster autoscaler
      Low
      20-40%
    
Use spot for stateless
      Medium
      60-70%
    
Schedule dev environments
      Low
      60%+
    
Switch to ARM64
      Medium
      20-40%
    
Optimize storage classes
      Low
      30-50%
    
Measuring Success
Track these metrics weekly:
Cost per pod-hour — Should decrease over time
Resource utilization — Target 60-70%
Spot instance percentage — Aim for 50%+ of compute
Idle resource hours — Should trend toward zero
Conclusion
Kubernetes cost optimization isn’t a one-time project — it’s an ongoing practice. Start with the quick wins (autoscaling, spot instances), then build toward a FinOps culture where every team understands their infrastructure costs.
The best part? These optimizations often improve performance too. Right-sized pods schedule faster, and autoscaling handles traffic spikes better than fixed capacity.
Start today: Install Kubecost, review your top 10 most expensive workloads, and right-size them. You’ll likely find 30%+ savings in your first week.
What’s your Kubernetes cost optimization strategy? The cloud bill never lies.

Kubernetes Cost Optimization: 10 Strategies to Cut Your Cloud Bill in Half

댓글