Certified Kubernetes Application Developer | CKAD Exam 2026

Explain why Kubernetes is essential for deploying and managing containerized apps across multiple virtual machines, enabling automatic scaling, health checks, and resilient lifecycle management.

Explore the Kubernetes introduction and basic architecture, including master and worker nodes, pods and containers, and how developers or administrators interact with clusters via API, CLI, or GUI.

Explore the Kubernetes architecture by detailing the master node components—api server, etcd, controller manager, and scheduler—and how they manage worker nodes, kubelet, and kube-proxy to run pods and expose services.

Explore Kubernetes installation options, from managed cloud services (EKS, GKE, AKS) to mini cube for development and manual installation on master‑worker clusters.

Install kubernetes as a managed service using DigitalOcean, compare costs with Amazon Web Services and Google Cloud, create a two-node cluster, and access via the Kubernetes dashboard and config file.

Learn how to access and interact with a managed Kubernetes cluster using kubectl, configure kubeconfig, and run basic commands on a Digital Ocean Kubernetes cluster.

Learn how to manually install Kubernetes with kubeadm across a multi-node cluster (master and workers), configure containerd and Calico networking, and join workers for CKAD exam prep.

Define, build, and modify container images for CKAD. Learn to execute containers, design multi-container port designing, and use persistent and ephemeral volumes.

Learn what a Docker image is, how it provides the operating system for a container, and how Kubernetes pulls and runs it from Docker Hub or private repositories.

Understand how Docker Hub repository works, including base, child, official, and user images, image tagging (latest), and pulling images for Kubernetes deployments.

Create a fresh ubuntu-based digital ocean droplet and install docker following the official documentation. Verify the setup by running the hello-world container and explore docker hub for official images.

Learn to push custom docker images to docker hub by tagging, logging in, and pushing under your username, then deploy them in your Kubernetes workflows.

Create a custom docker image with a dockerfile, selecting a base image and layering your application with run, copy, entrypoint, then expose ports and define a startup command.

Create a custom Docker image from a Dockerfile in Visual Studio Code. Define a base image, install engine x, build and push to Docker Hub, then deploy on Kubernetes.

Create, modify, and build Docker images using the latest Python 3 base image, bake a Python program, run the container, tag and push to Docker repo, and deploy on Kubernetes.

Create a custom Python Docker image from the official Python base, bake in a Python program, and run it. Push the image to Docker Hub and deploy with Kubernetes.

Learn how Kubernetes APIs power resource management via REST API, using YAML/JSON configurations and API versions (v1, apps, batch, beta), accessible through CLI, GUI, and API clients.

Explore pods in Kubernetes, differentiating them from containers, and learn how a single pod can host multiple containers, share volumes and network, and manage container dependencies.

Master kubectl basics to create pods (imperative or YAML), apply configurations, and manage resources with get, describe, edit, logs, delete, and top using YAML or JSON output.

Explore practical kubectl commands to manage pods, including imperative creation, YAML deployment, describe and logs, editing images, and enabling metrics with the metrics server for top outputs.

Learn how to override container behavior in Kubernetes by using command and args in YAML to modify entry point and CMDs, with practical examples using BusyBox and Debian containers.

Generate Kubernetes manifests from the CLI using dry-run to output yaml for any resource. The yaml includes apiVersion, kind, metadata, container image and name, dns policy, restart policy, and ports.

Explore the multi container pod design, where a single pod runs multiple containers sharing a single IP, port, and volume, enabling inter-container communication and shared resources.

Avoid multi container port design in Kubernetes; place front-end and back-end on separate ports for flexibility. Enable independent scaling, prevent resource contention, and simplify configuration.

Shows how to create a multi container pod using a YAML file, and run two containers that share the same volume and network.

Discusses three design patterns for multi-container pods in Kubernetes—sidecar, adapter, and investor container—and starts with the sidecar design pattern and its demo.

Explore the sidecar multi-container pattern by running a main application container with a log exporter sidecar that shares a volume to process and export logs to an external system.

Explore the ambassador multi container design pattern, where the application uses a proxy container to reach the outer world. A three-container demo demonstrates the proxy data flow.

Explore the adapter multi-container pattern, where an adapter container mediates between applications to convert data formats, such as yaml to json, for downstream consumption.

Explore the init container design pattern in a multi-container pod, where init containers run first to prepare prerequisites, enforce order, and delay app startup until dependencies are available.

Explore how Kubernetes jobs run ad hoc tasks, create pods, and mark completion with batch v1, pod templates, and options like completions, parallelism, TTL after finished, and active deadline.

Learn how to run Kubernetes jobs by configuring a countdown job in a yaml file, launching pods, inspecting logs, and cleaning up completed jobs.

Learn how cron jobs in Kubernetes schedule recurring tasks, compare them with jobs, and configure timing with cron patterns and yaml templates.

Demonstrates creating a Kubernetes cron job to run a busybox task every minute via YAML using batch v1, showing how the cron job schedules and cleans up jobs.

Explore volumes in Kubernetes and how ephemeral and persistent storage serve stateless and stateful apps. Review emptyDir, hostPath, and disks like Google Cloud persistent disk and AWS Elastic Block Storage.

Explore how the emptyDir volume provides temporary scratch space for data in Kubernetes, shared by two containers, and is deleted when the port restarts or is deleted.

Explore hostPath volumes as ephemeral Kubernetes storage for temporary data in stateless apps, and mount a node file or directory into a pod.

Explore how Kubernetes persistent volumes and persistent volume claims enable abstract storage management, with storage classes, provisioning, resizing, and reclaim policies for dynamic provisioning.

Demonstrates creating a local storage class, a pv and pvc, and mounting the pvc in a pod to illustrate binding, wait for first consumer, and reclaim behavior.

Explore the Kubernetes application deployment section, covering deployment concepts, upgrade and rollback strategies, and rollout methods like blue-green, recreate, and rolling updates, plus Helm usage.

Explore how deployments in Kubernetes wrap pods to enable scaling, upgrades, rollback, and flexible rollout strategies like rolling updates, blue green, and recreate.

Explore labels in Kubernetes, metadata in key-value form attached to objects like pods and deployments, used to identify attributes, filter resources, and optionally attach environment or release information.

Learn to use kubectl labels to filter resources, view labels, and add, overwrite, or remove labels at runtime, enabling label-based selection and efficient resource management.

Learn how label selectors filter Kubernetes objects using attached labels, with services using selector, and deployments or jobs using matchLabels. Explore node selectors in ports to target specific nodes.

Create deployment yaml with replicas and a pod template to spin multiple engine x pods. Use kubectl to generate yaml with --dry-run=client -o yaml, list pods, and describe the deployment.

Discover Kubernetes deployment strategies, focusing on recreate and rolling update, their impact on downtime, traffic, and state handling for stateless and stateful apps.

Demonstrate the recreate deployment strategy by upgrading a Kubernetes deployment from version 5.0 to 6.0, showing how existing pods terminate and new pods roll out in one go.

Learn how rolling updates and rollbacks work in Kubernetes, including declarative and imperative upgrade methods, rollout status and history, and undoing to a specific revision.

Learn how to configure rolling update parameters like max surge, max unavailable, and min ready seconds in a Kubernetes deployment, and how to roll back with rollout history.

Scale and de-scale a deployment by editing the YAML or using kubectl scale, monitor rollout status, and configure autoscaling with min, max, and cpu thresholds.

Learn canary deployment, releasing updates to a subset of users for monitoring. Compare blue-green, running two versions and switching traffic instantly, with doubled resources and stateful data handling.

Demonstrates blue-green deployment in Kubernetes by creating blue and green deployments plus a load balancer, then switching traffic via selectors and rolling back by updating the load balancer.

Demonstrate a canary deployment in Kubernetes behind a canary service load balancer, contrasting with blue-green, routing traffic between two deployments and highlighting production routing with Istio or Route 53.

Learn Helm, Kubernetes package manager, and how to bundle resources into a chart for deploying across clusters. Use Helm to manage lifecycle, upgrades, downgrades, and sharing packages via Artifact Hub.

Install helm across Windows, Mac, and Linux, explore Artifact Hub charts, and install the Jenkins chart with a single helm install command on a Kubernetes cluster.

Deploy third-party applications on Kubernetes using helm charts. Connect to your cluster, install kubectl, and provision WordPress with a helm chart to expose services via a load balancer.

Learn to bake a custom helm chart by using helm create, editing values.yaml, and wiring deployments and services in templates; verify with helm lint to ensure a valid chart.

Package and deploy your application with helm by defining a chart and rendering templates, then manage releases with install, upgrade, rollback, delete, while observing deployments, services, and load balancers.

Explore the application, observability, and maintenance section of the CKAD 2025 curriculum, covering API definitions, health checks, monitoring container logs, and Kubernetes debugging.

Explore Kubernetes liveness probes as health checks that monitor app liveness and functional correctness, restarting containers when failures occur and configuring http, exec, or tcp probes.

Explore the yaml configuration of Kubernetes liveness probes, including http get, exec, and tcp types, with common parameters such as initial delay, period, timeout, and thresholds.

Demonstrate configuring Kubernetes liveness probes, including http and exec probes, to perform health checks on containers and trigger automatic restarts.

Understand readiness probes and how they ensure containers are ready to serve traffic, starting before traffic is routed, unlike liveness checks; cover HTTP, CMD, and TCP readiness types.

Watch a hands-on demo of Kubernetes health checks using readiness and liveness probes, configuring TCP sockets on ports 8080 and 8081, applying YAML, and observing startup and restarts.

Explore the Kubernetes monitoring overview, covering cluster and port monitoring to track uptime and resource usage across nodes with Prometheus, Grafana, Jaeger, Kubernetes dashboard, command-line interface, and Kube Watch.

Monitor Kubernetes from nodes through applications by tracking cpu, memory, network, storage, component health, pod health and resource use, plus container and application level metrics.

Explore Kubernetes monitoring tools like Sea Advisor, metric server, and cube estate mattresses. Learn how they collect pod and node metrics and expose them to the Kubernetes API.

Install and verify the Kubernetes metrics server, learn what metrics it exposes, and use kubectl top to monitor node and pod CPU and memory usage for scalable resource decisions.

Monitor Kubernetes cluster by listing nodes with kubectl get nodes and assessing resource utilization with kubectl top nodes. Verify component health with kubectl get componentstatus for controller, manager, and scheduler.

Learn Kubernetes monitoring by verifying the metric server in the cube system, inspecting resource utilization of nodes and pods, and saving cpu and memory data.

Explore the Kubernetes log pipeline, including data sources (application, cluster, and system logs), aggregation, storage, and visualization with Fluentd, Elasticsearch, and a visualization tool.

Discover how to collect and debug Kubernetes logs without a native solution, using kubectl logs, journalctl, and log aggregators for API server, scheduler, and etcd.

Demonstrates the sidecar pattern for logging in Kubernetes, where a sidecar reads logs from the main application via a shared volume and publishes them.

Learn to collect logs from Kubernetes pods and containers with kubectl logs, selecting pods, targeting containers with -c, and using --since, --tail, or --all-containers.

Troubleshoot Kubernetes application failures by listing ports in all namespaces, describing the problematic port, and checking pending or waiting statuses; verify Docker can pull the image, else fix image name.

Troubleshoot Kubernetes cluster failures by inspecting nodes, cluster info, component status, and logs with Cube CTL commands, and diagnose worker node issues such as memory, CPU, and network.

Explore application environment, configuration and security in the CKAD exam, detailing authentication, authorization and admission control, resource quotas, configuration map and secrets, understanding the service account, and security context.

Explore the concept of custom resource definitions in Kubernetes, how CRDs extend native objects, register resources, and manage lifecycle across API versions.

Discover how to configure and register a custom resource definition (CRD) in Kubernetes, including api version, group, plural, scope, schema, and CLI naming details.

Explore custom resource definitions in Kubernetes with a hands-on demo that creates CRDs, registers them with the API server, and demonstrates versioned schemas, validation, and deprecation.

Learn how authentication identifies and verifies users, then authorization grants privileges via policies and RBAC, and admission control enforces cluster rules before objects are persisted.

Kubernetes uses a resource pool with limited CPU and memory. Define container-level resource requests and limits to allocate minimum and maximum resources, ensuring the request is less than the limit.

Define resource requests and limits in Kubernetes YAML for containers, setting minimum memory and CPU (megabytes and milli cores) and maximum limits. See how these constraints protect cluster health.

demonstrates configuring Kubernetes resource requests and limits, defining minimum and maximum memory and CPU, applying a deployment, and diagnosing scheduling issues when resources are insufficient.

Explore how Kubernetes resource quotas enforce per-namespace limits to prevent resource contention in shared clusters, using admission control and quota objects to restrict deployments.

Demonstrates creating a Kubernetes resource quota in a namespace, defining CPU and memory limits and requests in YAML, applying quotas with kubectl, and observing quota enforcement.

Learn how Kubernetes config maps store non confidential configuration as key value data to decouple environment specific configuration from container images and support dev, test, and production settings.

Learn how to create Kubernetes config maps via imperative commands using from literal and from file, and via declarative YAML, including multi-line values and data structuring.

Discover how to use a Kubernetes config map in pods through environment variables, startup command arguments, and mounted volumes, with config map keys like value one and value two.

Shows how to create a Kubernetes config map game-demo and ingest it into pods using environment variables, command line arguments, or volumes with keys like player initialize and game properties.

Learn how to store sensitive data in Kubernetes using secrets, differentiate from config maps, and retrieve secrets as environment variables or files in volumes.

Create and manage Kubernetes secrets through imperative commands or declarative YAML, covering opaque, service account token, docker config, basic auth, TLS, bootstrap token types, and base64 encoding for YAML.

Learn to inject Kubernetes secrets into pods via environment variables or volumes, using secret key refs and file-based mounts, with declarative creation and base64 encoding.

Learn how to create and consume Kubernetes secrets in pods and volumes, including base64 encoding, secret YAML and imperative creation, reading environment variables, and mounting secret data as files.

Learn how Kubernetes security context defines privileges for containers and ports, including run as user, group, fsGroup, read only root file system, and precedence rules between container and port contexts.

Demonstrate applying a Kubernetes pod security context to run containers as non-root users, showing the impact on root vs non-root processes and volume permissions.

Explore how Kubernetes container security context specifies per-container settings, and how container-level security context overrides port-level settings defined in the port manifest, with run as user examples.

Shows how container level security context overrides port level security context in Kubernetes, using a two-container manifest with busybox images and distinct run as user values.

Understand how service accounts give identity to pod processes and authenticate with the Kubernetes API server, including namespace scope, default mappings, and creation methods (imperative and yaml).

Explore services and networking in Kubernetes, including understanding network policies, troubleshooting access to applications, and using ingress rules to expose services.

Learn how Kubernetes services provide a single IP or DNS for frontend and backend pods to communicate across the cluster, with automatic IP refresh, load balancing, and scaling.

Create a first service and endpoint in Kubernetes, linking deployments to a service, mapping ports 8080 to the target port 80, and exposing multiple pods via endpoints.

Explore Kubernetes service types—cluster IP, node port, and load balancer—where cluster IP stays internal, node port exposes outside, and load balancer uses cloud providers, with ingress as an alternative.

Learn how the cluster IP service type, the default Kubernetes service, provides an internal cluster IP for front-end to back-end communication inside the cluster, with no outside access.

Learn how to use selectors and labels to create dynamic endpoints for a Kubernetes service, enabling automatic endpoint updates as pods scale or restart.

Discover how the NodePort service in Kubernetes exposes a port on each worker node, routes traffic to the cluster IP service, and enables external access via the node port range.

Explore how the load balancer service type exposes Kubernetes apps externally, auto-creates node port and cluster IP, and simplifies DNS-based access while highlighting cloud provider costs.

Network policies isolate pods in Kubernetes by controlling ingress and egress. They define allowed sources, namespaces, and IP blocks to permit front end to database traffic.

Explore how to implement Kubernetes network policies by denying all ingress to MySQL and then selectively allowing frontend to MySQL traffic on port 3306, with WordPress as the front end.