Mastering Kubernetes Autoscaling - A Hands-On Guide to HPA

Kubernetes autoscaling is a crucial feature for managing application performance and resource utilization in dynamic environments. In this guide, we’ll focus on Horizontal Pod Autoscaling (HPA), exploring its implementation and benefits through practical examples.

Understanding Kubernetes Autoscaling#

Kubernetes offers several autoscaling mechanisms:

Horizontal Pod Autoscaler (HPA): Adjusts the number of pod replicas based on resource utilization or custom metrics.
Vertical Pod Autoscaler (VPA): Adjusts CPU and memory requests/limits for pods.
Cluster Autoscaler: Scales the number of nodes in a cluster.

Today, we’ll dive deep into HPA.

Setting Up HPA: A Step-by-Step Guide#

Step 1: Deploy a Sample Application#

First, let’s deploy a PHP Apache server:

1
apiVersion: apps/v1
2
kind: Deployment
3
metadata:
4
  name: php-apache
5
spec:
6
  selector:
7
    matchLabels:
8
      run: php-apache
9
  template:
10
    metadata:
11
      labels:
12
        run: php-apache
13
    spec:
14
      containers:
15
        - name: php-apache
16
          image: registry.k8s.io/hpa-example
17
          ports:
18
            - containerPort: 80
19
          resources:
20
            limits:
21
              cpu: 500m
22
            requests:
23
              cpu: 200m
24
---
25
apiVersion: v1
26
kind: Service
27
metadata:
28
  name: php-apache
29
  labels:
30
    run: php-apache
31
spec:
32
  ports:
33
    - port: 80
34
  selector:
35
    run: php-apache

Save this as deploy.yaml and apply it:

1
kubectl apply -f deploy.yaml

Step 2: Create an HPA#

We can create an HPA using a YAML file or a kubectl command. Let’s try both:

Using kubectl:

1
kubectl autoscale deployment php-apache --cpu-percent=50 --min=1 --max=10

Using YAML:

1
apiVersion: autoscaling/v2
2
kind: HorizontalPodAutoscaler
3
metadata:
4
  name: php-apache
5
spec:
6
  scaleTargetRef:
7
    apiVersion: apps/v1
8
    kind: Deployment
9
    name: php-apache
10
  minReplicas: 1
11
  maxReplicas: 10
12
  metrics:
13
    - type: Resource
14
      resource:
15
        name: cpu
16
        target:
17
          type: Utilization
18
          averageUtilization: 50

Save this as hpa.yaml and apply it:

1
kubectl apply -f hpa.yaml

Step 3: Generate Load#

To test our HPA, let’s generate some load:

1
kubectl run -i --tty load-generator --rm --image=busybox:1.28 --restart=Never -- /bin/sh -c "while sleep 0.01; do wget -q -O- http://php-apache; done"

Step 4: Observe HPA in Action#

Watch the HPA scale your deployment:

1
kubectl get hpa php-apache --watch

You should see the number of replicas increase as CPU utilization goes up.

Key Insights and Takeaways#

Resource Efficiency: HPA ensures your application has the right number of pods to handle the current load, optimizing resource usage.
Cost-Effective: By scaling down during low-traffic periods, HPA can help reduce cloud costs.
Improved Performance: Automatically scaling up during high-traffic periods helps maintain application performance.
Fine-Tuning Required: Finding the right balance for CPU threshold and min/max replicas may require some experimentation.
Metrics Server Importance: Ensure your cluster has a working Metrics Server for HPA to function properly.
Beyond CPU: While we focused on CPU-based autoscaling, HPA can also work with custom metrics for more specific scaling needs.

Conclusion#

Horizontal Pod Autoscaling is a powerful feature in Kubernetes that allows your applications to automatically adapt to changing workloads. By implementing HPA, you can ensure your applications remain responsive and efficient, regardless of traffic fluctuations.

As you continue your Kubernetes journey, experiment with different metrics and scaling policies to find the optimal configuration for your specific use cases. Remember, effective autoscaling is about finding the right balance between performance, resource utilization, and cost.

Happy Kuberneting!

Newsletter