Coder Legion - Recent posts tagged ckad

Kubernetes Autoscaling: HPA vs VPA Explained With Hands-On Practice

Wed, 01 Jul 2026 12:25:29 +0000

If you've ever wondered how Kubernetes knows when to spin up more pods or give a pod more memory, that's autoscaling — and it's one of those concepts that sounds intimidating until you actually do it yourself. Day 17 of the #40DaysOfKubernetes challenge is where it clicked for me.

What is Autoscaling in Kubernetes?

At its core, autoscaling means Kubernetes adjusts resources automatically based on demand. You don't manually intervene every time traffic spikes. There are two main types:

HPA (Horizontal Pod Autoscaler) — adds or removes pods based on CPU/memory usage
VPA (Vertical Pod Autoscaler) — adjusts the resources (CPU/memory) of existing pods

Think of HPA as hiring more staff when the shop gets busy. VPA is more like giving one staff member more tools to handle the workload alone.

What I Did — Setting Up HPA

First I deployed the sample php-apache app with defined CPU requests and limits:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: php-apache
spec:
  selector:
    matchLabels:
      run: php-apache
  template:
    metadata:
      labels:
        run: php-apache
    spec:
      containers:
      - name: php-apache
        image: registry.k8s.io/hpa-example
        ports:
        - containerPort: 80
        resources:
          limits:
            cpu: 500m
          requests:
            cpu: 200m

apiVersion: v1
kind: Service
metadata:
  name: php-apache
  labels:
    run: php-apache
spec:
  ports:
  - port: 80
  selector:
    run: php-apache

The key part is setting resources.requests.cpu — HPA needs this to calculate utilization. Without it, the autoscaler has nothing to measure against.

Then I created the HPA object targeting 50% average CPU utilization, with a minimum of 1 pod and maximum of 10. This is the declarative method:

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

While this is the imperative method:

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

Generating Load to Watch It Scale

This is the fun part. I ran a load generator in a separate pod — basically a loop hammering the apache service with requests:

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"

Then watched the HPA respond in real time:

kubectl get hpa php-apache --watch

Watching the replica count climb from 1 to several pods as CPU utilization crossed 50% made the whole concept land in a way that reading documentation never does.

HPA vs VPA — When Do You Use Which?

	HPA	VPA
Scales	Number of pods	Pod resource limits
Best for	Stateless apps with variable traffic	Apps where sizing is hard to predict upfront
Works with	CPU, memory, custom metrics	CPU and memory

In practice, most production workloads use HPA. VPA is useful during early deployment when you're still figuring out the right resource requests for an app.

Key Takeaway

Don't skip setting resources.requests in your deployment spec. HPA is blind without it. That one line is what connects your workload to the autoscaler.

Tips for passing CKAD exam at 1st attempt (2026 Edition)

Wed, 06 May 2026 09:49:54 +0000

How it all started

Last year we got news: our new client would be using Kubernetes extensively. I was both excited and scared, as I had only limited exposure to Docker in a professional setting, and K8s is the next level.

After doing some research, I had a chat with my boss which resulted in funding for both the KodeKloud platform and two attempts at the CKAD exam (we lucked out by buying the exam at half price during Cyber Week). That started the long process of learning Kubernetes from scratch under the guidance of Mumshad Mannambeth and his excellent CKAD course.

CKAD Exam Structure

The exam consists of ~20 practical tasks that you need to solve in 120 minutes. You are supervised by a proctor throughout the process.

As of 2026, you are required to use the PSI Secure Browser. This app monitors your system, kills unauthorized processes, and requires full access to your camera and microphone.

Important changes compared to previous years:

Copy-Paste: Past exams used a browser extension that made copy-pasting clunky. Now, it's seamless using either Ctrl+C / Ctrl+V or Ctrl+Shift+C / Ctrl+Shift+V.

Context Switching: While KodeKloud tests still use a simple context switch, both Killer.sh and the actual exam often require you to ssh into different nodes.

Aliases: In the past, people recommended setting up complex aliases like export do="--dry-run=client -o yaml". Now, because you frequently switch sessions via SSH, these aliases don't persist unless you re-apply them. The only pre-configured alias is k for kubectl.

The Ingress vs. Gateway API Situation

Around the turn of 2025/2026, the Gateway API became the new standard, and the traditional Nginx Ingress Controller was deprecated in many environments.

However, don't let that fool you! In my actual exam (April 2026), I had two tasks regarding Ingress and zero tasks regarding Gateway API. This shows that the curriculum still leans heavily on Ingress.

My advice: Be prepared for both. Mastering Gateway API is important for the future, but for the sake of the exam, make sure you can still write a classic Ingress YAML in your sleep.

Credly

Passing the exam results in a PDF certificate that verifies your skills. You can also showcase your achievement with a digital badge on Credly:

Navigating the Documentation

During the exam, you are allowed to use the official Kubernetes documentation, API docs, and discussion threads. This is crucial for copying YAML snippets that cannot be easily generated via imperative commands.

Resource	Strategy
Network Policy	Copy YAML (hard to memorize)
Persistent Volumes	Copy YAML (use `Ctrl+F` for "kind: PersistentVolume")
Probes	Memorize syntax or quick copy
Env Vars (Secrets/CM)	Memorize `env`, `envFrom`, `valueFrom` to save time
Ingress	Copy YAML
Resources/Limits	Memorize (simple syntax)
Init & Sidecars	Memorize (note: Native Sidecars use `restartPolicy: Always`)
SecurityContext	Better to memorize (can be tricky to find quickly)
CronJob	Use docs if you forget the cron schedule format

TIP: Before the exam, click through each resource in the docs to familiarize yourself with their location. Scrolling in the PSI browser can be painfully slow, so get used to using Ctrl+F.

The Learning Curve

The start of the course was the hardest part—grasping the depth of the Kubernetes ecosystem. Understanding the theory behind cluster components and dependencies was time-consuming but essential for context.

The Middle Section (Core Concepts to Kustomize) was the most useful.

Go Imperative: From day one, study imperative commands. You need to create pods, deployments, and services as fast as possible. k run, k create, and k expose are your best friends.
YAML Mastery: Learn to tweak resources quickly using k apply -f <filename>.
The Details: Remember the subtle differences, like port vs. targetPort vs. nodePort, or how Native Sidecars are now handled within the initContainers field.

The Final Stretch:
Don't skip the mock exams. I highly recommend the KodeKloud Mock Exam Series. They can be frustrating because a minor typo results in a zero score, but they keep you humble and precise. After these, I tackled Killer.sh, scoring 66/113 on my first try without rushing. It gave me the confidence I needed.

How long does it take?

I started with zero K8s knowledge in November 2025 and passed on April 24th, 2026. This included a 2-month break, followed by a final month of "crunching" the material.

Prepare yourself for around 4 months of learning at a steady pace, or faster if you are already familiar with some Kubernetes concepts.

My take? Don't over-test yourself. I was ready sooner than I thought. At some point, doing too many mock tests with rigid grading can actually degrade your confidence. If you find yourself stuck on minor caveats, step back, review the fundamentals, and then hit a Killer.sh session. If you can handle that environment, you are ready for the real thing.

Useful Links

Official CKAD Curriculum (GitHub) - Check what is actually on the exam.
Kubernetes Documentation - Your only allowed friend during the test.
Killer.sh - The best exam simulator (usually harder than the real thing!).
KodeKloud CKAD Course - My primary learning resource.
KodeKloud CKAD Mock exams - Mock tests to learn how to work under pressure of time.