Introduction to the CKA Certification

The Certified Kubernetes Administrator (CKA) certification is designed to ensure that Kubernetes administrators have the skills, knowledge, and competency to perform the responsibilities of Kubernetes administrators. The CKA is a hands-on, performance-based exam that requires you to solve multiple tasks from a command line running a Kubernetes cluster.

This series will comprehensively cover all domains tested in the exam while providing practical examples, hands-on exercises, and sample exam questions with detailed solutions.

Exam Overview

Exam Format

The CKA exam has the following characteristics:

  • Duration: 2 hours
  • Format: 100% performance-based (hands-on tasks in live Kubernetes environments)
  • Environment: Ubuntu 20.04 Linux with pre-configured vim/nano access
  • Questions: 15-20 performance-based tasks
  • Passing Score: 66%
  • Cost: $395 USD (includes one free retake)
  • Validity: 3 years

During the exam, you will have access to:

  • One terminal
  • The Kubernetes documentation website
  • Up to 6 Kubernetes clusters with different configurations

Exam Domains

The CKA exam curriculum covers the following domains:

  1. Cluster Architecture, Installation & Configuration (25%)

    • Manage role-based access control (RBAC)
    • Use Kubeadm to install a basic cluster
    • Manage a highly-available Kubernetes cluster
    • Provision underlying infrastructure to deploy a Kubernetes cluster
    • Perform a version upgrade on a Kubernetes cluster using Kubeadm
    • Implement etcd backup and restore

  2. Workloads & Scheduling (15%)

    • Understand deployments and how to perform rolling updates and rollbacks
    • Use ConfigMaps and Secrets to configure applications
    • Scale applications
    • Understand the primitives used to create robust, self-healing, application deployments
    • Understand how resource limits can affect Pod scheduling
    • Awareness of manifest management and common templating tools

  3. Services & Networking (20%)

    • Understand service networking
    • Deploy and configure network load balancer
    • Know how to use Ingress controllers and Ingress resources
    • Know how to configure and use CoreDNS
    • Choose an appropriate container network interface plugin

  4. Storage (10%)

    • Understand storage classes, persistent volumes
    • Understand volume mode, access modes and reclaim policies for volumes
    • Understand persistent volume claims primitive
    • Know how to configure applications with persistent storage

  5. Troubleshooting (30%)

    • Evaluate cluster and node logging
    • Understand how to monitor applications
    • Manage container stdout & stderr logs
    • Troubleshoot application failure
    • Troubleshoot cluster component failure
    • Troubleshoot networking

Preparation Strategy

1. Environment Setup

To practice effectively, you need a Kubernetes environment. Here are some options:

  • Minikube: Single-node Kubernetes cluster on your local machine
  • Kind (Kubernetes in Docker): Run multiple Kubernetes nodes in Docker containers
  • K3s/K3d: Lightweight Kubernetes distribution excellent for development
  • Cloud-based Kubernetes: Use GKE, EKS, or AKS for managed Kubernetes
  • kubeadm-based setup: Create multi-node clusters (most similar to exam environment)

For this training series, we recommend having:

  • A multi-node Kubernetes cluster for complex scenarios
  • A single-node cluster for quick testing (Minikube or Kind)

2. Study Resources

Essential resources:

  • Official Kubernetes documentation
  • This training series
  • The Kubernetes for CKA/CKAD simulator (available with exam registration)
  • Regular hands-on practice

Recommended reading schedule:

  • Week 1-2: Core concepts and cluster architecture
  • Week 3-4: Workloads, scheduling, and services
  • Week 5-6: Networking and storage
  • Week 7-8: Security and troubleshooting
  • Final weeks: Mock exams and practice questions

3. Time Management in the Exam

The CKA is time-constrained, so consider these strategies:

  • Flag difficult questions: Don’t spend too much time on any single question
  • Answer easy questions first: Build confidence and secure points
  • Use imperative commands: Save time by using command-line shortcuts
  • Use kubectl explain: Quick reference for object specifications
  • Leverage documentation bookmarks: Prepare useful documentation links in advance

4. Key Command-Line Tools

Mastery of these tools is essential:

  • kubectl: The primary CLI tool for Kubernetes
  • kubeadm: For cluster management
  • etcdctl: For etcd backup and restore operations
  • Basic Linux tools: grep, sed, awk, etc.

5. Imperative Commands

Learning to use imperative commands saves significant time on the exam:

# Create a pod quickly
kubectl run nginx --image=nginx

# Create a deployment quickly
kubectl create deployment nginx --image=nginx

# Create a service quickly
kubectl expose deployment nginx --port=80 --target-port=80 --type=NodePort

# Generate YAML without creating resources
kubectl run nginx --image=nginx --dry-run=client -o yaml > pod.yaml

Practice Environment Setup

Let’s create a minimal practice environment for working through this series:

Using Kind (Kubernetes in Docker)

  1. Install Kind (if not already installed):
# For Linux
curl -Lo ./kind https://kind.sigs.k8s.io/dl/v0.20.0/kind-linux-amd64
chmod +x ./kind
sudo mv ./kind /usr/local/bin/kind

# For macOS (using Homebrew)
brew install kind
  1. Create a multi-node cluster:
cat << EOF > kind-config.yaml
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
- role: control-plane
- role: worker
- role: worker
EOF

kind create cluster --config kind-config.yaml --name cka-practice
  1. Verify your cluster:
kubectl get nodes
  1. Setting kubectl aliases for productivity:
echo 'alias k=kubectl' >> ~/.bashrc
echo 'alias kgp="kubectl get pods"' >> ~/.bashrc
echo 'alias kgd="kubectl get deployments"' >> ~/.bashrc
echo 'alias kgs="kubectl get services"' >> ~/.bashrc
source ~/.bashrc

Sample Exam Question 1

Here’s an example of a CKA exam question with a solution:

Question: Create a new Pod called nginx-pod using the nginx:alpine image, running in the web namespace. The namespace does not exist yet.

Solution:

# Create the web namespace
kubectl create namespace web

# Create the nginx pod in the web namespace
kubectl run nginx-pod --image=nginx:alpine --namespace=web

To verify:

kubectl get pods -n web

Explanation:

  • First, we create the namespace that doesn’t exist
  • Then, we use the imperative run command to create a pod directly
  • Finally, we verify the pod is running with get pods

What’s Next

In the next part, we’ll dive into Kubernetes Core Concepts, where we’ll explore:

  • Kubernetes architecture components
  • The API primitives
  • Understanding Services, Pods, and deployments
  • Working with the Kubernetes API

👉 Continue to Part 2: Core Concepts