CKAD: Certified Kubernetes Application Developer Guide

CKAD: Kubernetes for Application Developers

The Certified Kubernetes Application Developer (CKAD) certification from the Cloud Native Computing Foundation (CNCF) validates your ability to design, build, configure, and expose cloud-native applications for Kubernetes. Unlike the CKA (Certified Kubernetes Administrator) which focuses on cluster administration, CKAD focuses entirely on application development and deployment.

CKAD is a 100% hands-on, performance-based exam. There are no multiple-choice questions. You solve real problems in real Kubernetes clusters using only kubectl, YAML, and your knowledge.

What Makes CKAD Unique

Completely Hands-On:

• No theoretical questions or multiple choice
• Solve 15-20 real-world problems in live Kubernetes clusters
• Must actually create, configure, and troubleshoot resources
• Speed and accuracy both matter

Time Pressure:

• 2 hours for 15-20 questions
• Average 6-8 minutes per question
• Some questions take 2 minutes, others take 15 minutes
• Time management is critical

kubectl Mastery Required:

• All tasks done via command line (kubectl)
• Must know imperative commands for speed
• YAML editing skills essential
• No GUI or web console available

Real Kubernetes:

• Work with actual Kubernetes clusters (v1.29 as of early 2025)
• All official Kubernetes documentation available during exam
• Can search kubernetes.io for syntax and examples
• Must know where to find information quickly

Exam Format and Structure

Exam Environment

Remote Proctored:

• Take from home or office with webcam
• Strict proctoring requirements (clean desk, no notes, one monitor)
• Live proctor monitors via webcam and screen sharing
• Chrome browser with PSI extension required

Terminal Environment:

• Linux terminal with kubectl pre-installed
• Multiple Kubernetes clusters (6-8 clusters)
• Each question specifies which cluster to use
• Must switch contexts between questions

Allowed Resources:

• kubernetes.io/docs - Official Kubernetes documentation
• kubernetes.io/blog - Kubernetes blog
• helm.sh/docs - Helm documentation (if Helm questions appear)
• No other websites or resources allowed
• Cannot access notes, books, or external sites

Tools Available:

• kubectl (Kubernetes CLI)
• vim, nano (text editors)
• tmux (terminal multiplexer)
• systemctl (for debugging if needed)

CKAD Exam Domains Breakdown

The CKAD exam is heavily weighted toward actual application development and deployment tasks.

Domain 1: Application Design and Build

Container Images:

• Choose appropriate base images
• Understand multi-stage Dockerfiles
• Build container images with best practices
• Use slim/distroless images for security
• Tag and version images properly

Jobs and CronJobs:

• Create Jobs for one-time tasks
• Implement CronJobs for scheduled tasks
• Configure parallelism and completions
• Handle Job failures and retries
• Set activeDeadlineSeconds and backoffLimit

Multi-Container Pods:

• Implement sidecar pattern (logging, monitoring sidecars)
• Use ambassador pattern (proxy containers)
• Implement adapter pattern (standardizing outputs)
• Init containers for setup tasks
• Share volumes between containers

Domain 2: Application Deployment

Deployment Strategies:

• Create and manage Deployments
• Perform rolling updates
• Rollback Deployments
• Scale Deployments horizontally
• Configure maxSurge and maxUnavailable
• Use kubectl rollout commands

Blue/Green and Canary Deployments:

• Understand deployment patterns
• Use labels and selectors for routing
• Manage multiple Deployment versions
• Switch traffic between versions

Helm Basics:

• Use Helm charts to deploy applications
• Install, upgrade, and rollback Helm releases
• Configure values.yaml
• Search Helm Hub/repositories
• Understand chart structure

Domain 3: Application Observability and Maintenance

Liveness and Readiness Probes:

• Configure HTTP, TCP, and exec probes
• Set initialDelaySeconds and periodSeconds
• Configure failureThreshold and successThreshold
• Understand probe differences and use cases
• Debug probe failures

Container Logging:

• View logs with kubectl logs
• Access logs from multi-container pods
• Stream logs in real-time
• Debug application issues via logs

Debugging Applications:

• Exec into running containers (kubectl exec)
• Check pod status and events
• Describe resources for troubleshooting
• Debug failed pods and containers
• Understand pod lifecycle and phases

Monitoring:

• Use kubectl top for resource usage
• Understand metrics server
• Monitor pod CPU and memory
• Identify resource-constrained pods

Domain 4: Application Environment, Configuration and Security

ConfigMaps and Secrets:

• Create ConfigMaps from literals, files, and directories
• Mount ConfigMaps as volumes
• Use ConfigMaps as environment variables
• Create Secrets for sensitive data
• Use Secrets in pods (volume mounts and env vars)
• Understand Secret types (Opaque, TLS, Docker registry)

Security Contexts:

• Set securityContext at pod and container level
• Configure runAsUser, runAsGroup, fsGroup
• Set capabilities (add/drop)
• Configure allowPrivilegeEscalation
• Implement read-only root filesystems

Service Accounts:

• Create and use Service Accounts
• Mount Service Account tokens
• Configure RBAC for Service Accounts
• Disable automatic token mounting
• Understand default Service Account

Resource Requirements:

• Set CPU and memory requests
• Set CPU and memory limits
• Understand QoS classes (Guaranteed, Burstable, BestEffort)
• Configure LimitRanges and ResourceQuotas
• Debug OOMKilled and resource issues

Domain 5: Services and Networking

Service Types:

• Create ClusterIP Services (default)
• Expose applications with NodePort
• Use LoadBalancer Services (cloud providers)
• Understand ExternalName Services
• Configure service selectors correctly

Network Policies:

• Implement NetworkPolicies for pod isolation
• Configure ingress and egress rules
• Use podSelector and namespaceSelector
• Allow/deny specific traffic
• Test NetworkPolicy effectiveness

Ingress:

• Create Ingress resources
• Configure path-based routing
• Implement host-based routing
• Use TLS/SSL with Ingress
• Understand Ingress Controllers

DNS and Service Discovery:

• Use Kubernetes DNS for service discovery
• Access services by DNS name
• Understand DNS naming conventions
• Debug DNS issues

Domain 6: State Persistence

Persistent Volumes and Claims:

• Create PersistentVolumeClaims
• Use PVCs in pod specifications
• Understand access modes (ReadWriteOnce, ReadWriteMany, ReadOnlyMany)
• Configure storage classes
• Understand volume binding modes

Volume Types:

• Use emptyDir for temporary storage
• Mount hostPath volumes (with cautions)
• Use ConfigMap and Secret volumes
• Understand ephemeral volumes
• Implement volume mounts correctly

StatefulSets:

• Deploy StatefulSets for stateful applications
• Configure volumeClaimTemplates
• Understand stable network identities
• Manage StatefulSet updates and scaling

kubectl Mastery for CKAD

Speed is everything in CKAD. You must know kubectl imperative commands to create resources quickly, then edit YAML as needed.

Essential Imperative Commands

Create Resources Fast:

# Create deployment (fastest way)
kubectl create deployment nginx --image=nginx --replicas=3

# Create pod with command
kubectl run busybox --image=busybox --command -- sleep 3600

# Create service
kubectl expose deployment nginx --port=80 --target-port=80 --type=ClusterIP

# Create job
kubectl create job hello --image=busybox -- echo "Hello World"

# Create cronjob
kubectl create cronjob hello --image=busybox --schedule="*/5 * * * *" -- echo "Hello"

# Create configmap
kubectl create configmap app-config --from-literal=key1=value1 --from-literal=key2=value2
kubectl create configmap app-config --from-file=config.properties

# Create secret
kubectl create secret generic db-secret --from-literal=password=mypass
kubectl create secret tls tls-secret --cert=tls.crt --key=tls.key

# Create namespace
kubectl create namespace dev

# Create service account
kubectl create serviceaccount app-sa

Generate YAML for Editing:

# Dry run to generate YAML (don't create resource)
kubectl run nginx --image=nginx --dry-run=client -o yaml > pod.yaml
kubectl create deployment nginx --image=nginx --dry-run=client -o yaml > deploy.yaml
kubectl expose pod nginx --port=80 --dry-run=client -o yaml > service.yaml

# Then edit and apply
vim pod.yaml
kubectl apply -f pod.yaml

Quick Edits:

# Edit running resource
kubectl edit deployment nginx

# Set image (for updates)
kubectl set image deployment/nginx nginx=nginx:1.21

# Scale
kubectl scale deployment nginx --replicas=5

# Autoscale
kubectl autoscale deployment nginx --min=2 --max=10 --cpu-percent=80

Troubleshooting Commands:

# Describe for details
kubectl describe pod nginx-pod
kubectl describe deployment nginx

# Logs (essential for debugging)
kubectl logs nginx-pod
kubectl logs nginx-pod -c sidecar-container
kubectl logs nginx-pod --previous  # Previous crashed container
kubectl logs -f nginx-pod  # Follow/stream logs

# Exec into container
kubectl exec -it nginx-pod -- /bin/bash
kubectl exec nginx-pod -- ls /app
kubectl exec nginx-pod -c sidecar -- /bin/sh

# Port forward for testing
kubectl port-forward pod/nginx-pod 8080:80
kubectl port-forward service/nginx 8080:80

# Check resource usage
kubectl top nodes
kubectl top pods

# Get events
kubectl get events --sort-by=.metadata.creationTimestamp
kubectl get events -n kube-system

# Check pod in all namespaces
kubectl get pods -A
kubectl get pods --all-namespaces

# Delete quickly
kubectl delete pod nginx-pod --force --grace-period=0

Time-Saving Aliases and Shortcuts

Add these to your exam terminal at the start:

# Set default namespace
kubectl config set-context --current --namespace=dev

# Aliases (create at exam start)
alias k=kubectl
alias kgp='kubectl get pods'
alias kgd='kubectl get deployments'
alias kgs='kubectl get services'
alias kdp='kubectl describe pod'
alias kdd='kubectl describe deployment'
alias kl='kubectl logs'
alias kx='kubectl exec -it'

# Short names
k get po          # pods
k get deploy      # deployments
k get svc         # services
k get ns          # namespaces
k get cm          # configmaps
k get ing         # ingress
k get pv          # persistentvolumes
k get pvc         # persistentvolumeclaims

Context Switching (Critical for CKAD)

Each question specifies a cluster context. You MUST switch contexts or you'll work in the wrong cluster (and get 0 points).

# Check current context
kubectl config current-context

# List available contexts
kubectl config get-contexts

# Switch context (DO THIS FIRST for each question)
kubectl config use-context 

# Verify correct context
kubectl config current-context
kubectl get nodes  # Quick sanity check

Exam Tip: Copy the context switch command from each question and run it immediately. This is the most common mistake - working in the wrong cluster.

YAML Editing Tips

Use vim efficiently:

# In vim
:set nu           " Show line numbers
:set paste        " Paste mode (prevents auto-indent issues)
dd                " Delete line
5dd               " Delete 5 lines
yy                " Copy line
p                 " Paste
u                 " Undo
ctrl+r            " Redo
/searchterm       " Search
n                 " Next match
:%s/old/new/g     " Replace all
:wq               " Save and quit
:q!               " Quit without saving

Common YAML Patterns:

Multi-container pod:

apiVersion: v1
kind: Pod
metadata:
  name: multi-pod
spec:
  containers:
  - name: app
    image: nginx
  - name: sidecar
    image: busybox
    command: ['sh', '-c', 'while true; do sleep 30; done']

ConfigMap as environment variable:

spec:
  containers:
  - name: app
    image: myapp
    envFrom:
    - configMapRef:
        name: app-config

Resource requests/limits:

spec:
  containers:
  - name: app
    image: nginx
    resources:
      requests:
        memory: "64Mi"
        cpu: "250m"
      limits:
        memory: "128Mi"
        cpu: "500m"

Study Resources and Learning Path

Official CKAD Resources

• description

  CKAD Exam Curriculum - Official exam topics on GitHub

  open_in_new
• description

  Kubernetes Documentation - Your primary resource, available during exam

  open_in_new
• link

  CKAD Exam Tips - Official exam policies

  open_in_new

Recommended Courses

• school

  Kubernetes for Developers (LFD259) - Official Linux Foundation course

  open_in_new
• school

  CKAD Course by KodeKloud - Highly recommended, includes labs

  open_in_new
• school

  Mumshad's CKAD Course on Udemy - Popular with practice tests

  open_in_new

Hands-On Practice Platforms

• 🔬 Killer.sh - Included free with exam registration, hardest practice available
• 🔬 KodeKloud CKAD Labs - Game of Pods challenges
• 🔬 Katacoda Kubernetes Scenarios - Free interactive scenarios
• 🔬 Kind or Minikube - Local Kubernetes for practice

Community Resources

• 📘 Kubernetes in Action (Manning) - Excellent book for deep understanding
• play_circle

  TechWorld with Nana CKAD - Free YouTube CKAD content

  open_in_new
• 💬 Kubernetes Slack - #ckad channel - Community support
• 💬 Reddit r/kubernetes - Questions and tips

Practice Exams

• 📝 Killer.sh Simulator - Free with registration, most realistic and harder than real exam
• 📝 KodeKloud Practice Tests - Part of their CKAD course
• 📝 GitHub CKAD Exercises - Free practice problems

6-Week CKAD Study Plan

Week 1: Kubernetes Fundamentals

• Install and configure local Kubernetes (minikube/kind)
• Master kubectl basics and imperative commands
• Create pods, deployments, services manually
• Practice YAML syntax and editing
• Learn context switching
• Lab Time: 10-15 hours

Week 2: Application Deployment

• Deep dive into Deployments and ReplicaSets
• Practice rolling updates and rollbacks
• Configure pod resource requests/limits
• Implement Jobs and CronJobs
• Understand multi-container pod patterns
• Lab Time: 10-15 hours

Week 3: Configuration and Storage

• Master ConfigMaps and Secrets
• Practice mounting configurations as files and env vars
• Implement PersistentVolumes and PersistentVolumeClaims
• Work with different volume types
• Configure SecurityContexts
• Lab Time: 12-15 hours

Week 4: Networking and Services

• Create all Service types (ClusterIP, NodePort, LoadBalancer)
• Implement NetworkPolicies
• Configure Ingress resources
• Practice service discovery and DNS
• Debug networking issues
• Lab Time: 12-15 hours

Week 5: Observability and Troubleshooting

• Configure liveness and readiness probes
• Master kubectl logs and debugging
• Practice exec into containers
• Use kubectl top for monitoring
• Troubleshoot failing pods and applications
• Lab Time: 10-12 hours

Week 6: Practice and Speed Drills

• Take killer.sh practice exam (2 hours)
• Complete time-boxed exercises (6 minutes per question)
• Review and retry all failed scenarios
• Speed drill kubectl commands
• Review exam tips and strategies
• Take killer.sh again
• Practice Time: 15-20 hours

Total Study Time: 70-90 hours over 6 weeks

Recommended Daily Practice Routine

During Study Phase (Weeks 1-5):

• Morning (30-60 minutes): Watch course video or read documentation
• Evening (60-90 minutes): Hands-on labs in your own Kubernetes cluster
• Weekend (3-4 hours each day): Extended practice sessions with timed drills

Final Week Practice:

• Monday-Tuesday: killer.sh practice exam #1, review all mistakes
• Wednesday-Thursday: Speed drills, focus on weak areas
• Friday: killer.sh practice exam #2, compare improvements
• Saturday: Light review, no heavy studying
• Sunday: Rest day before exam

Quick Reference: Most Common CKAD Tasks

Create Resources (Imperative - Fastest):

kubectl run nginx --image=nginx --labels=app=frontend,tier=web
kubectl create deployment api --image=myapi:v1 --replicas=3
kubectl expose deployment api --port=8080 --target-port=80 --name=api-service
kubectl create job data-import --image=postgres:14 -- psql -f import.sql
kubectl create cronjob backup --image=backup:latest --schedule="0 2 * * *" -- /backup.sh

Modify Resources:

kubectl scale deployment api --replicas=5
kubectl set image deployment/api api=myapi:v2
kubectl rollout undo deployment/api
kubectl rollout status deployment/api
kubectl autoscale deployment api --min=2 --max=10 --cpu-percent=75

Verification (Always Check):

kubectl get pods -l app=frontend
kubectl describe deployment api
kubectl logs -f pod/api-7d4f8c9b-xk2pq
kubectl get events --sort-by=.metadata.creationTimestamp | tail -10

Critical Exam Tips and Strategies

Time Management Strategy

1. 1

   Read all questions first (5 minutes)

   • Mark easy vs hard questions
   • Plan your approach
   • Identify high-value questions
2. 2

   Do easy questions first (60 minutes)

   • Complete questions you're confident about
   • Bank points quickly
   • Build confidence
3. 3

   Tackle medium questions (40 minutes)

   • Work through moderate difficulty
   • Don't spend more than 8-10 minutes per question
   • Flag and move on if stuck
4. 4

   Attempt hard questions (10-15 minutes)

   • Give difficult questions best effort
   • Partial credit is possible
   • Don't leave blank

Speed Optimization

1. 1 Use imperative commands - Don't write YAML from scratch
2. 2 Master --dry-run=client -o yaml - Generate YAML, then edit
3. 3 Bookmark important docs - Pre-find YAML examples during exam
4. 4 Use aliases - Set up k=kubectl immediately
5. 5 Copy-paste from docs - Find example YAML in kubernetes.io
6. 6 Skip describe when possible - kubectl get is faster for basic info

Documentation Navigation

Bookmark these pages at exam start:

• Pod specification examples
• Deployment examples
• Service examples
• ConfigMap and Secret examples
• NetworkPolicy examples
• PersistentVolume examples

Search efficiently:

• Use site search on kubernetes.io
• CTRL+F to find specific sections
• Know where examples live
• Don't read full documentation - find the example and adapt

Common Mistakes to Avoid

1. 1

   Working in wrong context - Always verify context first

   # FIRST THING for each question:
   kubectl config use-context 
   kubectl config current-context  # Verify

2. 2

   Not checking your work - Verify resources are running

   kubectl get pods  # Are they Running?
   kubectl get svc   # Is service created?
   kubectl describe pod   # Any errors?

3. 3

   Overthinking - Simplest solution is usually correct

   • Question asks for a pod? Create a pod (not deployment)
   • Question specifies ClusterIP? Don't create NodePort
   • Follow instructions exactly
4. 4

   Ignoring partial credit - Attempt every question

   • Even incomplete answers can earn partial points
   • If stuck after 10 minutes, make your best attempt and move on
5. 5

   Fighting with vim - Practice vim before exam

   • Know basic commands: i (insert), Esc (exit insert), :wq (save quit), dd (delete line)
   • Set up at exam start: :set nu (line numbers), :set paste (paste mode)
6. 6

   Not using documentation - It's allowed, use it!

   • Don't memorize obscure YAML syntax
   • Find examples in docs and adapt them
   • Use browser search (Ctrl+F) effectively
7. 7

   Spending too long on one question - Move on and come back

   • If question takes >12 minutes, flag and move on
   • Complete easier questions first
   • Return to hard ones if time permits

Real Exam Workflow (Per Question)

1. 1 Read question carefully (30 seconds)
2. 2 Copy context switch command and execute (15 seconds)
3. 3 Verify correct context (10 seconds)
4. 4 Create resource using imperative command or dry-run (2-5 minutes)
5. 5 Edit YAML if needed for complex requirements (1-3 minutes)
6. 6 Apply and verify resource is created and running (1-2 minutes)
7. 7 Test if required (e.g., exec into pod, curl service) (1-2 minutes)
8. 8 Move to next question

Total per question: 6-8 minutes average

Practice Questions

Frequently Asked Questions

---

CKAD Success Formula:

1. 1 kubectl mastery - Speed comes from imperative commands
2. 2 Hands-on practice - 50-80 hours minimum
3. 3 Time management - Practice with time limits
4. 4 Documentation skills - Know where to find examples
5. 5 Calm under pressure - Stay focused, don't panic

The CKAD exam is fair - it tests real-world skills you need as a Kubernetes developer. Master kubectl, practice extensively, and manage your time well, and you'll pass!