CKA: Certified Kubernetes Administrator Complete Guide

Resource Management:

apiVersion: v1
kind: Pod
metadata:
  name: resource-demo
spec:
  containers:
  - name: app
    image: nginx
    resources:
      requests:
        memory: "128Mi"
        cpu: "250m"
      limits:
        memory: "256Mi"
        cpu: "500m"

Domain 3: Services & Networking

Services:

# ClusterIP (default)
kubectl expose deployment nginx --port=80 --target-port=80

# NodePort
kubectl expose deployment nginx --type=NodePort --port=80

# LoadBalancer
kubectl expose deployment nginx --type=LoadBalancer --port=80

# Create service from YAML
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: ClusterIP

Ingress:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: app-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  ingressClassName: nginx
  rules:
  - host: app.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: app-service
            port:
              number: 80

NetworkPolicies:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: db-policy
  namespace: production
spec:
  podSelector:
    matchLabels:
      app: database
  policyTypes:
  - Ingress
  - Egress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: backend
    ports:
    - protocol: TCP
      port: 3306
  egress:
  - to:
    - podSelector:
        matchLabels:
          app: monitoring
    ports:
    - protocol: TCP
      port: 9090

DNS and CoreDNS:

# Check CoreDNS
kubectl get pods -n kube-system -l k8s-app=kube-dns

# CoreDNS ConfigMap
kubectl get configmap coredns -n kube-system -o yaml

# Test DNS resolution
kubectl run test-dns --image=busybox --rm -it -- nslookup kubernetes.default

# Service DNS format
# ..svc.cluster.local

Domain 4: Storage

PersistentVolumes and PersistentVolumeClaims:

# PersistentVolume
apiVersion: v1
kind: PersistentVolume
metadata:
  name: pv-data
spec:
  capacity:
    storage: 10Gi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: /mnt/data

---
# PersistentVolumeClaim
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-data
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 5Gi

---
# Use in Pod
apiVersion: v1
kind: Pod
metadata:
  name: app
spec:
  containers:
  - name: app
    image: nginx
    volumeMounts:
    - name: data
      mountPath: /usr/share/nginx/html
  volumes:
  - name: data
    persistentVolumeClaim:
      claimName: pvc-data

StorageClass:

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: fast-storage
provisioner: kubernetes.io/aws-ebs
parameters:
  type: gp3
  iops: "3000"
  encrypted: "true"
volumeBindingMode: WaitForFirstConsumer

Domain 5: Troubleshooting

Cluster Component Troubleshooting:

# Check node status
kubectl get nodes
kubectl describe node worker01

# Check kubelet logs
sudo journalctl -u kubelet -f
sudo systemctl status kubelet

# Check kube-apiserver
kubectl get pods -n kube-system
kubectl logs kube-apiserver-controlplane -n kube-system

# Check cluster info
kubectl cluster-info
kubectl get cs  # component status (deprecated)

# Check certificates
kubeadm certs check-expiration

Pod Troubleshooting:

# Check pod status
kubectl get pods
kubectl get pods -o wide
kubectl describe pod myapp

# Check logs
kubectl logs myapp
kubectl logs myapp -c container-name
kubectl logs myapp --previous

# Debug with exec
kubectl exec -it myapp -- /bin/bash
kubectl exec myapp -- cat /etc/config/app.conf

# Debug with ephemeral container
kubectl debug myapp -it --image=busybox --target=myapp

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

Network Troubleshooting:

# Test DNS
kubectl run test --image=busybox --rm -it -- nslookup kubernetes.default

# Test connectivity
kubectl run test --image=busybox --rm -it -- wget -O- http://service-name

# Check endpoints
kubectl get endpoints service-name

# Check network plugins
kubectl get pods -n kube-system | grep -i network

Critical kubectl Command Mastery

Time-Saving Imperative Commands

# Create resources quickly
kubectl run nginx --image=nginx --port=80
kubectl create deployment web --image=nginx --replicas=3
kubectl expose deployment web --port=80 --target-port=80

# Generate YAML
kubectl run nginx --image=nginx --dry-run=client -o yaml > pod.yaml
kubectl create deployment web --image=nginx --dry-run=client -o yaml > deploy.yaml

# Quick edits
kubectl edit deployment web
kubectl set image deployment/web nginx=nginx:1.21
kubectl scale deployment web --replicas=5

# Labels and selectors
kubectl label pods myapp env=prod
kubectl get pods -l env=prod
kubectl get pods --show-labels

# Annotations
kubectl annotate pods myapp description="Web server"

# Resource usage
kubectl top nodes
kubectl top pods
kubectl top pods --containers

# Copy files
kubectl cp myapp:/app/config.yaml ./config.yaml
kubectl cp ./data.txt myapp:/tmp/

Context and Namespace Management

# View contexts
kubectl config get-contexts
kubectl config current-context

# Switch context (CRITICAL for exam)
kubectl config use-context cluster1

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

# Work with namespaces
kubectl get pods -n kube-system
kubectl get pods -A  # All namespaces
kubectl create namespace dev

Exam-Specific Aliases

Set these at the beginning of the exam:

alias k=kubectl
alias kgp='kubectl get pods'
alias kgs='kubectl get svc'
alias kgn='kubectl get nodes'
alias kdp='kubectl describe pod'
alias kds='kubectl describe service'
alias kex='kubectl exec -it'
alias klo='kubectl logs'
export do="--dry-run=client -o yaml"

Study Resources

Official CNCF Resources

• description

  CKA Curriculum - Official exam topics on GitHub

  open_in_new
• description

  Kubernetes Documentation - Available during exam

  open_in_new
• school

  Kubernetes the Hard Way - Learn cluster setup from scratch

  open_in_new

Recommended Courses

• school

  Kubernetes Fundamentals (LFS258) - Official Linux Foundation course

  open_in_new
• school

  CKA Course by KodeKloud - Highly recommended with labs

  open_in_new
• school

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

  open_in_new

Hands-On Practice

• 🔬 Killer.sh - Included free with exam, hardest practice available
• 🔬 KodeKloud CKA Labs - Lightning Labs for speed practice
• 🔬 Kind, Minikube, or kubeadm - Build local clusters for practice

Practice Exams

• 📝 Killer.sh Simulator - Free with registration, most realistic
• 📝 KodeKloud Mock Exams - Part of course
• quiz

  GitHub CKA Exercises - Free practice problems

  open_in_new

8-Week Study Plan

Week 1-2: Cluster Architecture & Installation

• Install Kubernetes with kubeadm
• Understand cluster components
• Practice cluster upgrades
• Master RBAC configuration
• Lab Time: 15-20 hours

Week 3-4: Workloads & Scheduling

• Master Deployments, DaemonSets, StatefulSets
• Configure resource requests/limits
• Practice scheduling (taints, tolerations, affinity)
• Work with ConfigMaps and Secrets
• Lab Time: 15-20 hours

Week 5-6: Networking & Services

• Create all Service types
• Implement Ingress controllers
• Configure NetworkPolicies
• Troubleshoot DNS and connectivity
• Lab Time: 15-20 hours

Week 7: Storage & Troubleshooting

• Implement PV and PVC
• Configure StorageClasses
• Master troubleshooting techniques
• Practice etcd backup/restore
• Lab Time: 15-20 hours

Week 8: Speed Drills & Mock Exams

• Take Killer.sh exam (2 hours)
• Complete time-boxed scenarios (6-8 minutes each)
• Review weak areas
• Speed drill kubectl commands
• Take Killer.sh again
• Practice Time: 20-25 hours

Exam Strategies

Time Management

1. 1 Read all questions first (5 minutes) - Identify easy wins
2. 2 Do easy questions first (60 minutes) - Bank points quickly
3. 3 Tackle medium questions (40 minutes) - Work through challenges
4. 4 Attempt hard questions (15 minutes) - Give best effort

Critical Exam Tips

1. 1 Always verify context first:

kubectl config use-context 
kubectl config current-context  # Verify

1. 1 Use imperative commands - Don't write YAML from scratch
2. 2 Verify your work:

kubectl get 
kubectl describe 
kubectl logs   # For workload issues

1. 1

   Bookmark important docs during exam:

   • Pod specification examples
   • NetworkPolicy examples
   • RBAC examples
   • etcd backup commands
2. 2

   Don't spend >8 minutes on one question - Flag and move on

Common Mistakes to Avoid

1. 1 ❌ Working in wrong context - Always verify!
2. 2 ❌ Not checking your work - Verify resources are running
3. 3 ❌ Writing YAML from scratch - Use imperative + dry-run
4. 4 ❌ Ignoring partial credit - Attempt every question
5. 5 ❌ Overthinking - Keep solutions simple
6. 6 ❌ Not using documentation - It's allowed, use it!

Practice Questions

Frequently Asked Questions

CKA Success Formula:

1. 1 Hands-on practice - 80+ hours minimum in real clusters
2. 2 kubectl mastery - Know imperative commands by heart
3. 3 Speed drills - Practice under time constraints
4. 4 Troubleshooting skills - Learn to debug quickly
5. 5 Documentation navigation - Know where to find examples fast

CKA is the gold standard for Kubernetes administration certification. It proves you can actually manage production Kubernetes clusters, not just answer questions about them!