← Back to Blog

Kubernetes Autoscaling: HPA, VPA, and Cluster Autoscaler

📅 2025-11-06T12:52:07.201Z⏱️ 5 min read✍️ Robson Alves
#kubernetes#devops#cloud
Kubernetes Autoscaling: HPA, VPA, and Cluster Autoscaler

Kubernetes Autoscaling: HPA, VPA, and Cluster Autoscaler

In today’s dynamic cloud environments, managing application workloads efficiently is crucial. Imagine a scenario where your web application handles millions of requests during peak times but only a fraction of that during off-hours. Manually scaling resources to handle such variability can be cumbersome and error-prone.

Understanding autoscaling in Kubernetes is essential as it helps optimize resource usage, reduce costs, and ensure high availability. By the end of this blog post, you'll learn how Horizontal Pod Autoscaler (HPA), Vertical Pod Autoscaler (VPA), and Cluster Autoscaler work together to manage your Kubernetes clusters efficiently.

Understanding the Basics

Kubernetes autoscaling is a feature that automatically adjusts the number of resources your application needs based on demand. This ensures that applications can handle varying loads seamlessly without manual intervention.

There are three primary types of autoscalers in Kubernetes: Horizontal Pod Autoscaler (HPA), Vertical Pod Autoscaler (VPA), and Cluster Autoscaler. Each serves a different purpose but works together to optimize resource management.

Horizontal Pod Autoscaler (HPA)

Horizontal Pod Autoscaler automatically adjusts the number of pod replicas in a deployment, replica set, stateful set, or replication controller based on observed CPU utilization (or other select metrics).

How HPA Works

HPA monitors the CPU usage of pods and scales up by adding more replicas if necessary. Conversely, it reduces the number of replicas if CPU usage drops below the specified threshold.

# Example HPA configuration
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: php-apache
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: php-apache
  minReplicas: 1
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 50 # Target CPU utilization at 50%

This configuration sets up HPA for a deployment named php-apache, ensuring it scales between 1 and 10 replicas based on 50% CPU usage.

Vertical Pod Autoscaler (VPA)

Vertical Pod Autoscaler automatically adjusts the resource requests and limits of pods to improve application performance without manual intervention. VPA is particularly useful when you don't have precise metrics for optimal resource allocation.

How VPA Works

VPA operates in three modes: Off, Initial, and Recreate. In Initial mode, it sets initial values based on historical usage data. In Recreate mode, it updates resources by deleting and recreating pods with new configurations.

# Example VPA configuration
apiVersion: "autoscaling.k8s.io/v1"
kind: VerticalPodAutoscaler
metadata:
  name: vpa-resource-consumer
spec:
  targetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: resource-consumer
  updatePolicy:
    updateMode: "Recreate" # Recreate pods to apply new resources

This configuration sets VPA for a deployment named resource-consumer, using the Recreate mode to update resource requests and limits.

Cluster Autoscaler

Cluster Autoscaler automatically adjusts the size of your Kubernetes cluster by adding or removing nodes based on demand. It helps ensure that all pods have a node to run on while optimizing costs by reducing unnecessary resources during low-traffic periods.

How Cluster Autoscaler Works

Cluster Autoscaler monitors resource requests and limits across all namespaces and scales up the cluster if there are insufficient resources. Conversely, it scales down the cluster when nodes are underutilized.

# Example command to install Cluster Autoscaler
kubectl apply -f https://raw.githubusercontent.com/kubernetes/autoscaler/master/cluster-autoscaler/cloudprovider/aws/examples/cluster-autoscaler-autodiscover.yaml

# Configure autoscaler with min and max node count
kubectl -n kube-system set env deployment.apps/cluster-autoscaler \
  AUTO_DISCOVERY=true \
  SCAN_INTERVAL=10s \
  EXPANDER=random \
  SKIP_NODES_WITH_SYSTEM_PODS=false \
  BALANCE_SIMILAR_NODE_GROUPS=true \
  MIN_NODES=2 \
  MAX_NODES=10

This command installs and configures Cluster Autoscaler for an AWS EKS cluster, setting it to manage node groups between 2 and 10 nodes.

Integrating HPA, VPA, and Cluster Autoscaler

Integrating these three autoscalers provides a comprehensive approach to managing Kubernetes resources. Here’s how they work together:

  • HPA handles the number of pod replicas based on CPU or other metrics.
  • VPA adjusts resource requests and limits for optimal performance.
  • Cluster Autoscaler manages the number of nodes in the cluster.

Example Integration Scenario

Consider a web application with varying traffic patterns. During peak times, HPA increases the number of pod replicas to handle increased load. VPA ensures that each pod has adequate resources allocated based on historical data. If additional resources are still needed beyond what the existing nodes can provide, Cluster Autoscaler scales up the cluster by adding more nodes.

Troubleshooting

Common Issues with HPA

  • Metric Server Unavailability: Ensure the Metric Server is running and correctly configured.
  • Incorrect Target Metrics: Verify that the specified metrics (e.g., CPU utilization) are accurate.
# Check if Metric Server is running
kubectl get deployment metric-server -n kube-system

Common Issues with VPA

  • Pod Disruption: Be cautious when using Recreate mode, as it can cause downtime.
  • Historical Data Inaccuracy: Ensure that historical data used by VPA is representative of actual usage.
# Check VPA recommendations
kubectl get vparesourcepolicy -o yaml

Common Issues with Cluster Autoscaler

  • Node Group Configuration: Ensure node groups are correctly configured for autoscaling.
  • Cluster API Limits: Be aware of cluster API limits that can affect scaling operations.
# Check Cluster Autoscaler logs for errors
kubectl logs -n kube-system deployment.apps/cluster-autoscaler

Conclusion

Autoscaling is a critical component in managing Kubernetes clusters efficiently. By leveraging Horizontal Pod Autoscaler, Vertical Pod Autoscaler, and Cluster Autoscaler, you can ensure that your applications perform optimally under varying loads while minimizing costs.

Key Takeaways:

  1. HPA adjusts the number of pod replicas based on CPU or other metrics.
  2. VPA modifies resource requests and limits for optimal performance.
  3. Cluster Autoscaler manages the size of your Kubernetes cluster by adding or removing nodes.

⚠️ Warning: Always test autoscaling configurations in a staging environment before deploying to production.

By understanding and implementing these autoscalers, you can significantly enhance the reliability and efficiency of your Kubernetes deployments.