Kubernetes CKAD course & hands-On [ 2026 ]

Discover how containers solve the 'it works on my machine' problem by packaging code and dependencies into lightweight units that run from development to production, and how Kubernetes manages them.

Define, build, and deploy container images for Kubernetes using Docker and a Dockerfile, then modify, redeploy, and debug pods with kubectl.

Explore two core Kubernetes multi-container pod patterns—init containers and sidecar containers—demonstrating startup preparation, continuous support, and practical kubectl workflows.

Explore how microservices break apps into small, independent services and how Kubernetes automates deployment, scaling, service discovery, and self-healing for reliable, scalable systems.

Explore how Kubernetes automates deployment, scaling, and management of containerized apps, solving manual scaling, failure recovery, and multi-machine networking with declarative YAML manifests.

Learn Kubernetes core components: control plane with etcd, API server, controller manager, and scheduler, plus worker nodes with kubelet, kube-proxy, and runtime that runs containers.

Explore how Kubernetes objects express the cluster’s desired state, covering workloads, networking, configuration, security, storage, and custom resources, plus imperative, yaml, and declarative management.

Discover how Kubernetes namespaces provide logical partitioning and isolation for resources like pods, services, and config maps across dev, stage, and prod environments within a single cluster.

Organize and isolate Kubernetes resources across teams and multi-environment setups with namespaces, create a dev namespace, deploy a nginx pod, switch context, and clean up.

Learn how Kubernetes labels attach key-value metadata to pods, services, and deployments, enabling precise selection, automation, and scalable management through YAML manifests and kubectl commands.

Attach metadata to Kubernetes resources using labels, then create, view, and update labels on pods. Filter and select pods by label values to organize resources efficiently during creation or later.

Attach non-identifying metadata to Kubernetes objects with annotations, using key-value pairs for informational data like configuration details, debugging information, and tool integration, enabling automation and auditing.

Learn to apply kubernetes annotations to pods for monitoring and documentation, add or modify metadata, inspect with kubectl describe, and clean up resources.

Learn how Kubernetes selectors filter resources by labels to target services, deployments, and policies. Explore equality-based, set-based, and match-label selectors for dynamic resource targeting and lightweight cluster impact.

Filter Kubernetes resources with field selectors by targeting predefined fields like name and status phase, enabling efficient command line interface and API queries for running pods.

Master field selectors to filter Kubernetes resources by status and metadata. Use pods, nodes, services, and jobs with kubectl examples for running pods, specific names, and cleanup.

Apply a consistent set of Kubernetes labels across all resources, using app.kubernetes.io/name, app.kubernetes.io/instance, app.kubernetes.io/version, app.kubernetes.io/component, app.kubernetes.io/part-of, and app.kubernetes.io/managed-by to ensure interoperability and easier management.

Install minikube on macOS using homebrew or the docker driver, start a local Kubernetes cluster, access the dashboard, verify kubectl, and stop or delete when finished.

Open the hands-on Kubernetes project in Visual Studio Code by loading the folder with YAML manifests and readme guides. Use organized exercises and mock exams to practice Kubernetes commands.

Explore pods, the basic unit of execution in Kubernetes, where one or more containers share network and storage to enable easy scaling, management, and automatic restarts.

Learn to create Kubernetes pods with both declarative YAML and imperative kubectl commands. Debug and troubleshoot pods using get, describe, logs, exec, and clean up with delete.

Manage replicated pods in Kubernetes to ensure the desired state, high availability, and zero-downtime updates with automated scaling.

Create and manage Kubernetes deployments with declarative YAML and imperative commands to maintain replicas and perform rolling updates, then debug and troubleshoot using kubectl.

Explore blue-green deployment in Kubernetes, where blue and green environments run parallel, traffic shifts to green after validation for minimal downtime and easy rollback.

Create blue and green deployments with declarative YAML in VSCode, running nginx 1.21 and 1.22, then switch traffic using service labels. Debug pods and deployments with kubectl.

Learn how canary deployments in Kubernetes gradually roll out new versions to a small subset of users, with traffic routing, monitoring, and safe production testing.

Learn to implement canary deployment using declarative yaml to run stable and canary nginx versions with traffic split 25% canary, 75% stable, and promote via kubectl scale and rollout status.

Replica sets are Kubernetes objects that keep a stable number of pods running, automatically replacing failed pods for fault tolerance and enabling deployment or scaling.

Create a replica set from a declarative yaml file and maintain three nginx pods, then apply with kubectl and debug with get, describe, and logs to see automatic pod recreation.

Stateful sets provide stable network identities and persistent storage for stateful apps, ensuring ordered deployment, scaling, and deletion of pods for databases and distributed systems using persistent volume claims.

Learn to create and manage stateful sets for stateful applications with stable network identities and per-pod persistent storage using declarative yaml and imperative kubectl commands, plus debugging and lifecycle behaviors.

DaemonSets ensure one pod per node for cluster-wide services, solving issues where deployments miss nodes. Cluster admins deploy node-level tasks like logging and monitoring.

Create a daemonset to run a fluentd logging agent on all nodes using a YAML file, then debug and manage it with kubectl.

Learn how Kubernetes jobs manage finite tasks by creating pods that run to completion, automatically retrying failed pods, enabling batch processing and tasks like database migrations, analytics, and backups.

Create a Kubernetes job that runs a pod to completion with completions and parallelism using yaml. Then create it imperatively, and learn to describe, get pods, view logs, and cleanup.

Explore how Kubernetes cron jobs schedule recurring tasks using cron expressions, creating jobs at specified times to automate backups, reports, and cleanups without manual intervention.

Explore how to create and manage Kubernetes cron jobs using declarative YAML and imperative kubectl commands. Learn debugging, monitoring, and cleanup of scheduled jobs and their pods.

Learn how Kubernetes' horizontal pod autoscaler automatically scales deployments, replica sets, or stateful sets based on CPU or memory usage to meet demand while optimizing resources.

Create and troubleshoot a horizontal pod autoscaler for an nginx deployment by using declarative YAML and imperative kubectl commands, to scale between min and max replicas based on CPU utilization.

Vertical Pod Autoscaler (VPA) automatically adjusts CPU and memory allocations for pods in Kubernetes, ensuring sufficient resources while preventing overprovisioning and underprovisioning as workloads evolve.

Explore how the vertical pod autoscaler automatically adjusts CPU and memory inside pods to keep workloads efficient, using recommender, updater, and admission controller components, and its compatibility with HPA.

Discover how Kubernetes cluster ip service, the default service type, provides internal, stable virtual ip addresses for pod-to-pod communication and load balances microservice traffic inside the cluster.

Learn to create a cluster IP service in Kubernetes using declarative YAML and imperative kubectl, enabling internal pod communication and debugging endpoints.

NodePort exposes an application externally on a static port across all cluster nodes, enabling access without a cloud load balancer (for example, port 30008 maps to 3200 and pods 3000).

Create and verify a node port service to expose nginx pods externally on port 30080, using declarative YAML and imperative commands, then test access from inside and outside the cluster.

Explore how Kubernetes load balancer services expose apps to the internet by provisioning a load balancer and distributing traffic across pods and nodes with cloud providers like AWS and GCP.

Create and verify a load balancer service to expose an nginx pod externally, using declarative YAML and imperative commands, then debug, test, and clean up.

Explore headless services in Kubernetes, which expose individual pods directly via DNS records with no cluster IP, enabling direct pod discovery for stateful workloads like databases and queues.

Create a headless Kubernetes service with no cluster IP to expose direct pod IP addresses through DNS, enabling pod-to-pod communication for stateful workloads, tested with DNS lookups and wget.

Ingress consolidates external access to multiple Kubernetes services via a single entry point, enabling routing, SSL termination, and load balancing; an ingress controller such as Nginx enforces the rules.

Expose external traffic to multiple services using a Kubernetes ingress. Create an ingress with YAML, configure minikube, and route by path to services A and B via nginx ingress.

Control pod-to-pod traffic with Kubernetes network policies to restrict access and isolate services. Define allowed inbound and outbound traffic by selectors, ports, and protocols, with defaults denying all else.

Learn to implement Kubernetes network policies to control pod communication, using yaml and kubectl across a Minikube cluster with Cilium cni; test with labeled pods and debug.

Learn how Kubernetes DNS provides stable, name-based service discovery for services and pods, enabling reliable cross-pod communication across namespaces with minimal overhead.

Discover how Kubernetes DNS enables pod and service communication using names, test resolution with nslookup and curl, and deploy nginx and BusyBox pods with YAML and kubectl.

Explore volumes in Kubernetes, including ephemeral volumes like emptyDir tied to the pod lifecycle and persistent volumes such as NFS for long term storage.

Enable durable, pod-independent storage in Kubernetes with persistent volumes (PVs) that survive restarts, bound to PVCs and backed by backends like AWS EBS or NFS.

Kubernetes introduces persistent volume claims that let developers dynamically request storage, decoupling provisioning from consumption and binding PVCs to suitable persistent volumes for durable app data.

Configure and bind persistent volumes and claims in Kubernetes, attach them to a pod via yaml, and verify data persists after pod recreation, demonstrating stateful storage.

Enable ephemeral volumes in kubernetes for temporary, pod-scoped storage that is deleted on pod termination; use with caches, scratch space, or transient data.

Configure and verify an ephemeral emptyDir volume in a pod using yaml, mount it at /tmp, and confirm data disappears when the pod is deleted.

storage classes in kubernetes enable dynamic provisioning of persistent volumes by specifying a storage type, provisioner parameters, and reclaim policies, automating storage for pvcs and pvs.

Configure and use a Kubernetes storage class on minikube with hostpath, enabling dynamic persistent volume provisioning via a PVC, mounting the volume in a BusyBox pod.

Explore dynamic volume provisioning in Kubernetes, which automatically creates persistent volumes for PVC requests, eliminating manual storage pre-creation and speeding deployments through storage classes and CSI drivers.

Explore Kubernetes storage capacity awareness and how PVCs bind to PVs to provide pods with correct persistent storage. Specify capacity in PVC manifests with Gibibytes GI and dynamic provisioning.

Define environment variables as key value pairs injected via the env field in pod specs to configure runtime settings in Kubernetes, enabling separation of configuration from code.

Learn to define environment variables in Kubernetes using declarative YAML and imperative kubectl commands. Create and inspect pods, reference configmaps for config data, and troubleshoot with describe and exec commands.

Learn how Kubernetes configmaps store non-sensitive configuration as key-value pairs, separating config from code and enabling dynamic updates via environment variables or mounted files.

Learn to manage configuration data with Kubernetes ConfigMaps using declarative YAML and the imperative kubectl method, then inject config values into pods as environment variables.

Discover how Kubernetes secrets securely store sensitive data like passwords and API keys, using encryption or base64 encoding, and control access via environment variables or mounted files.

Learn to manage sensitive data in Kubernetes by creating base64-encoded secrets with YAML, injecting them as environment variables into pods, and verifying with kubectl commands.

Define security contexts to enforce fine-grained pod and container security in Kubernetes, configuring user IDs, group IDs, file permissions, and privilege levels for production workloads.

Configure and use security contexts in Kubernetes to run pods as non-root, set fsGroup and user, manage Linux capabilities, and enforce restricted privileges with pod and container level rules.

Learn how Kubernetes liveness, readiness, and startup probes automatically monitor container health, ensure only ready pods serve traffic, and restart unhealthy containers to improve application reliability.

Learn to configure Kubernetes probes—liveness, readiness, and startup—through a declarative yaml pod setup, and verify, troubleshoot, and manage probes with kubectl.

Explore how Kubernetes uses resource requests and limits to fairly allocate CPU and memory. Understand how requests, limits, and scheduling decisions prevent contention, starvation, and overcommitment, ensuring cluster stability.

Learn to set resource requests and limits for pods and containers in Kubernetes using yaml files. Apply, verify, and troubleshoot with kubectl to ensure proper resource allocation and prevent contention.

Create and use a crontab CRD to extend Kubernetes with a new resource type, define fields, apply with kubectl, and inspect resources using get and describe.

Explore how pod security standards and admission enforce secure, compliant pod configurations in Kubernetes by applying privileged, baseline, and restricted profiles through admission controllers during pod creation.

Explore how pod security standards enforce the restricted policy in Kubernetes, demonstrating compliant vs non-compliant pods within a secure namespace and the admission-level checks that block privileged configurations.

Discover how Kubernetes service accounts give pods a secure identity to authenticate with the API, enable RBAC-based access, and securely inject credentials.

Explore configuring and using service accounts in Kubernetes through declarative YAML and imperative kubectl methods, then associate them with a pod and practice debugging and cleanup under role-based access control.

Kubernetes rbac enforces secure access control by defining roles, binding users or service accounts, and restricting actions on cluster resources to close auditing gaps.

Configure rbac in kubernetes by defining a pod reader role with get and list in the default namespace and binding it to developer. Verify with kubectl can, then clean up.

Explore how Kubernetes policies enforce security and resource usage through network policies, limit ranges, and resource quotas. Learn who uses them, when they apply, and how to create them.

Learn how Kubernetes resource quotas cap cpu, memory, storage, and the number of objects per namespace to prevent resource exhaustion, ensure fair distribution, and maintain cluster stability.

Configure resource quotas in Kubernetes to enforce fair CPU, memory, and pod limits per namespace using declarative YAML and kubectl.

Explore how limit range in Kubernetes sets minimum, maximum, and default resource limits for containers in a namespace, covering cpu, memory, and storage requests and usage.

Configure limit ranges in Kubernetes to enforce min, max, and default resource values for pods and containers across namespaces; use yaml to define limits and kubectl to apply and verify.

Assign pods to nodes in Kubernetes by the scheduler, guided by node selectors, affinity, and tolerations to optimize resources and balance workloads.

Learn how node selector in Kubernetes matches pod requirements with node labels to place pods on matching nodes, enabling simple, efficient pod scheduling with minimal overhead.

Learn to use node selector to assign pods to specific nodes via label-based rules in a YAML manifest and verify scheduling with kubectl commands.

Learn node affinity in Kubernetes to control pod placement using node labels. Define hard and soft rules in pod specs for selecting nodes with resources like CPU, GPU, and SSD.

Learn to use node affinity in Kubernetes to place pods on nodes with specific labels, using hard required during scheduling and soft preferred rules, with match expressions and SSD example.

Master taints and tolerations to control Kubernetes pod placement, enabling node isolation, workload isolation, and safe maintenance by matching taint keys, values, and effects.

Control pod placement on specific nodes using taints and tolerations in kubernetes. Apply a taint to a node and create a tolerating pod to demonstrate restricted and allowed scheduling.

Understand pod priority and preemption in Kubernetes, where high priority pods evict lower priority pods to guarantee scheduling under resource pressure, with administrators defining priority classes.

This hands-on session demonstrates Kubernetes pod priority and preemption, creating low and high priority classes, simulating resource constraints, and deploying preemptive and critical pods to manage scheduling.