Your cart is empty.
Keep shopping
Teach on Udemy
Turn what you know into an opportunity and reach millions around the world.
Learn MoreCKAD Certified Kubernetes Application Developer [2026]
CKAD Certified Kubernetes Application Developer [2026]
CKAD | Kubernetes | CKA Essentials | CKAD Certification | Certified Kubernetes Application Developer
Created byPraveenkumar Bouna
Last updated 8/2026
English
EnglishSpanish [Auto],
What you'll learn
- Master kubectl command-line operations.
- Create and deploy containerized applications.
- Write and manage YAML manifests.
- Configure application networking.
- Implement multi-container Pod patterns.
- Troubleshoot applications effectively using kubectl.
- Set up local Kubernetes environments.
- Configure resource management.
- Master essential terminal skills including Vim editing.
Course content
16 sections • 266 lectures • 16h 33m total length
- Overview of the CKAD Exam4:22
After this lecture, you will be able to describe the CKAD exam prerequisites, format, duration, scoring, and retake and certification validity policies.
- Create your First Deployment - Demo4:00
After this lecture, you will be able to use Killercoda to list nodes, create an nginx deployment, view its status, scale replicas up and down, and delete the deployment.
- How to Take This Course?1:50
After this lecture, you will be able to explain how the course is structured and decide whether to follow it sequentially or jump to specific topics based on your exam experience.
- Skills Measured in the CKAD Exam4:50
After this lecture, you will have an understanding of the skills measured in the CKAD exam and their respective weightage.
- Helpful Resources for Exam Preparation2:24
After this lecture, you will know the official CKAD exam curriculum, the Killer.sh exam simulator, and other resources to help you prepare for the exam.
- Join the Discord Community0:11
- Activity: Review CKAD Candidate Handbook0:22
- Activity: Review CKAD Curriculum0:38
- Important Prerequisites Notice2:05
Explore essential prerequisite tools and concepts for the CKAD exam, including Linux terminal basics, vim, YAML and JSON syntax, and kubectl fundamentals, to accelerate exam readiness.
- Setting up Kubernetes for Exam Preparation6:29
After this lecture, you will be able to install and verify a local Kubernetes cluster using Docker Desktop, minikube, kind, or k3s, and configure kubectl aliases for faster command entry.
- Getting Started with SSH4:27
After this lecture, you will be able to connect to a remote host over SSH, run commands remotely, and exit an SSH session.
- SSH Command
- Getting Started with kubectl7:08
After this lecture, you will be able to explain the structure of a kubectl command and construct commands using the command, type, name, and flags components.
- Getting Started with kubectl - Demo4:37
After this lecture, you will be able to check cluster and kubectl versions, list API resources, and use kubectl's built-in help and explain features.
- kubectl Command
- Effective Terminal Usage in the Exam5:12
After this lecture, you will be able to use copy-paste shortcuts, right-click menus, and a multi-terminal workflow to work efficiently in the exam environment.
- Vim Essentials for Kubernetes16:10
After this lecture, you will be able to use essential vim commands to open, navigate, edit, and save YAML files, including indenting and searching text, during the exam.
- Vim Essentials
- Kubernetes Architecture - Overview2:18
After this lecture, you will be able to describe the Kubernetes client-server architecture and explain how a request flows from the API server through the scheduler and kubelet to a running container.
- Kubernetes Architecture - Control Plane Components3:39
After this lecture, you will be able to identify the control plane components, kube-apiserver, kube-scheduler, etcd, kube-controller-manager, and cloud-controller-manager, and describe their roles.
- Kubernetes Architecture - Worker Node Components3:43
After this lecture, you will be able to identify the worker node components, kubelet, container runtime, and kube-proxy, and describe how they run and network pods.
- Kubernetes Architecture
- Kubernetes Architecture Alignment Meeting
- Container Concepts4:28
After this lecture, you will be able to distinguish between container runtimes such as Docker Engine, containerd, and CRI-O, and container tools such as Docker and Podman.
- CKAD Exam Requirements - Containers1:23
Master CKAD exam readiness by focusing on how containers work with Kubernetes, covering basic Docker knowledge: build, run, inspect, and troubleshoot containers, while avoiding advanced Docker topics.
- Creating Container Images5:32
After this lecture, you will be able to write a simple Python application and a Dockerfile that defines how to build it into a container image.
- Building a Container Image7:50
After this lecture, you will be able to build a Docker image with docker image build and list, inspect, and tag the resulting images.
- Docker Images
- Running Containers7:11
After this lecture, you will be able to run, name, list, stop, start, remove, and inspect containers, and view their logs using docker container commands.
- Image Distribution6:06
After this lecture, you will be able to log in to a registry, tag an image for it, and push and pull images to and from a remote registry such as Docker Hub.
- Docker Containers
- Introducing Containers for Cloud-Native Development
- Kubernetes Object Management - Overview1:14
After this lecture, you will be able to distinguish between the imperative, declarative, and hybrid approaches for managing Kubernetes objects.
- Kubernetes Object Management - Imperative Approach3:59
After this lecture, you will be able to create, expose, and scale Kubernetes resources directly from the command line using imperative kubectl commands.
- Kubernetes Object Management - Declarative Approach5:40
After this lecture, you will be able to create a Pod from a YAML manifest using kubectl apply and explain the last-applied-configuration annotation and the desired-versus-current state model.
- Kubernetes Object Management - Hybrid Approach1:52
After this lecture, you will be able to generate a resource manifest with --dry-run=client -o yaml, edit it, and apply it using the hybrid approach.
- Kubernetes Object Management - Choosing the Right Approach - Exam Tips1:39
After this lecture, you will be able to choose the imperative, declarative, or hybrid approach based on the requirements of a given exam task.
- Choosing the Right Kubernetes Object Management Approach
- Node - Overview3:58
After this lecture, you will be able to list cluster nodes, view their details, and describe the role of nodes in running workloads.
- Namespace - Overview3:19
After this lecture, you will be able to explain the purpose of namespaces and identify Kubernetes' built-in namespaces and their access levels.
- Namespace - Creating and Managing Namespaces2:46
After this lecture, you will be able to create, list, and view details of namespaces using kubectl.
- Namespace - Assigning Namespaces3:30
After this lecture, you will be able to create resources in a specific namespace, list resources scoped to a namespace, view resources across all namespaces, and delete a namespace along with its resources.
- Label - Overview2:48
After this lecture, you will be able to identify common label patterns used for environment, application, version, and team classification.
- Label - Applying Labels3:35
After this lecture, you will be able to apply labels to existing resources, label resources at creation time, and label multiple resources at once.
- Label - Managing Labels2:13
After this lecture, you will be able to update, remove, and view labels on Kubernetes resources.
- Label Selectors - Overview1:19
After this lecture, you will be able to explain the purpose of label selectors and the difference between equality-based, set-based, and manifest-based selector types.
- Label Selectors - Set-based Selectors4:56
After this lecture, you will be able to filter resources using set-based selectors with the in, notin, and exists operators, including combining them with equality-based selectors.
- Label Selectors - Equality-based Selectors4:20
After this lecture, you will be able to filter resources using equality-based selectors with =, ==, and != and combine multiple conditions with AND logic.
- Label Selectors - Manifest-based Selectors1:27
After this lecture, you will be able to use manifest-based selectors to filter resources based on label requirements defined in a YAML file.
- Label and Label Selectors - Exam Tips2:34
After this lecture, you will be able to apply the correct selector syntax and quoting rules, and use --show-labels to validate label application on exam tasks.
- Annotation - Introduction and Concepts2:01
After this lecture, you will be able to identify common annotation patterns used for build information, ownership, and configuration hints.
- Annotation - Applying Annotations2:38
After this lecture, you will be able to add annotations to existing resources and set annotations at creation time, including in bulk.
- Annotation - Managing Annotations1:58
After this lecture, you will be able to update, overwrite, remove, and view annotations on Kubernetes resources.
- Labels vs Annotations1:38
After this lecture, you will be able to distinguish between labels and annotations by their purpose, queryability, and typical use cases.
- Pod - Overview3:33
After this lecture, you will be able to describe what a Pod is, why it's the smallest deployable unit in Kubernetes, and how containers within a Pod share network and storage.
- Pod - Manifest Structure3:26
After this lecture, you will be able to identify the key fields of a Pod manifest, apiVersion, kind, metadata, spec, and status, and write a basic Pod YAML.
- Pod - Creating Using Imperative Approach5:53
After this lecture, you will be able to create a Pod imperatively with kubectl run and inspect it using get, describe, and wide output.
- Pod - Creating Using Declarative Approach2:11
After this lecture, you will be able to create a Pod declaratively from a YAML manifest file using kubectl apply.
- Pod - Creating Using Hybrid Approach3:23
After this lecture, you will be able to generate a Pod manifest with --dry-run=client -o yaml and apply it using the hybrid approach.
- Pod - Lifecycle2:20
After this lecture, you will be able to identify the possible Pod phases, Pending, Running, Succeeded, Unknown, and Failed, and what each phase indicates.
- Pod - Executing Commands in Containers5:28
After this lecture, you will be able to execute commands inside a running container both from the terminal with kubectl exec and by configuring a command in the Pod manifest.
- Pod - Executing Commands in Containers - Exam Tips2:05
After this lecture, you will be able to recall and apply the most frequently used kubectl exec command pattern for running commands in a container during the exam.
- Pod - Deleting a Pod2:46
After this lecture, you will be able to delete a Pod using both the imperative and declarative approaches, including a forced immediate deletion.
- ReplicaSet - Overview2:51
After this lecture, you will be able to explain how a ReplicaSet maintains a desired number of running Pod replicas.
- ReplicaSet - Manifest Structure2:55
After this lecture, you will be able to identify the structure of a ReplicaSet manifest, including its replicas, selector, and Pod template fields.
- ReplicaSet - Creating Using Declarative Approach4:48
After this lecture, you will be able to create a ReplicaSet declaratively from a manifest and verify the Pods it creates.
- ReplicaSet - Deleting a ReplicaSet1:44
After this lecture, you will be able to delete a ReplicaSet and its Pods using both the imperative and declarative approaches.
- ReplicaSet Pod Adoption Behavior - Exam Tips0:47
- Deployment - Overview4:21
After this lecture, you will be able to explain how a Deployment manages ReplicaSets and Pods, and describe its use cases for rollout, rollback, and scaling.
- Deployment - Manifest Structure3:37
After this lecture, you will be able to identify the structure of a Deployment manifest and how it combines ReplicaSet and Pod specifications.
- Deployment - Creating Using Imperative Approach5:14
After this lecture, you will be able to create a Deployment imperatively with kubectl create deploy and inspect the ReplicaSet and Pods it creates.
- Deployment - Creating Using Hybrid Approach3:42
After this lecture, you will be able to generate a Deployment manifest using --dry-run=client -o yaml and apply it using the hybrid approach.
- Deployment - Applying Labels2:43
After this lecture, you will be able to add a label to an existing Deployment with kubectl label, since labels cannot be set at creation with --labels.
- Deployment - Deleting a Deployment1:46
After this lecture, you will be able to delete a Deployment along with its ReplicaSet and Pods using both imperative and declarative approaches.
- StatefulSet - Overview5:41
After this lecture, you will be able to explain how a StatefulSet provides stable network identity, stable storage, and ordered deployment for stateful Pods.
- StatefulSet - Creating a StatefulSet5:44
After this lecture, you will be able to create a StatefulSet with a volumeClaimTemplate and expose its Pods through a headless Service.
- StatefulSet - StatefulSet vs Deployment3:32
After this lecture, you will be able to compare StatefulSets and Deployments by pod identity, storage, deployment order, and typical use cases.
- DaemonSet - Overview3:58
After this lecture, you will be able to explain how a DaemonSet ensures a copy of a Pod runs on every, or selected, node and identify its common use cases.
- DaemonSet - Creating a DaemonSet4:44
After this lecture, you will be able to create a DaemonSet declaratively and verify that one Pod is scheduled per node.
- DaemonSet - Deleting a DaemonSet1:23
After this lecture, you will be able to delete a DaemonSet and confirm its Pods are removed from every node.
- Role Play: Choosing Between StatefulSet and Deployment for Cloud Migration
- Jobs - Overview6:14
After this lecture, you will be able to describe a Job's manifest structure, including completions, backoffLimit, parallelism, and restartPolicy.
- Jobs - Creating a Job using Imperative Approach3:24
After this lecture, you will be able to create a Job imperatively with kubectl create job and track its completion status.
- Jobs - Job Creation Workflow2:05
Submit a job and have the API server validate and store it, returning status. Let the job controller spawn pods, which spin up containers on nodes.
- Jobs - Creating a Job using Hybrid Approach4:10
After this lecture, you will be able to generate a Job manifest with --dry-run=client -o yaml and apply it using the hybrid approach.
- Jobs - Lifecycle Attributes4:26
After this lecture, you will be able to explain the completions, backoffLimit, and parallelism attributes that control a Job's lifecycle.
- Jobs - Deleting a Job2:45
After this lecture, you will be able to delete a Job using both the imperative and declarative approaches and verify its Pods are removed.
- CronJob - Overview3:06
After this lecture, you will be able to explain how a CronJob creates Jobs on a repeating schedule and identify common scheduling use cases.
- CronJob - Manifest Structure2:31
After this lecture, you will be able to identify the nested CronJob, Job, and Pod spec sections within a CronJob manifest.
- CronJob - Cron Pattern2:45
After this lecture, you will be able to write a CronJob schedule using standard cron syntax.
- CronJob - Creating a CronJob using Imperative Approach4:28
After this lecture, you will be able to create a CronJob imperatively with kubectl create cronjob and observe it trigger Jobs on schedule.
- CronJob - CronJob Creation Workflow1:40
Explore how Kubernetes cron jobs use a schedule managed by the cron job controller to automatically spin up new job instances, contrasting with standard job workflows.
- CronJob - Creating a CronJob using Hybrid Approach3:39
After this lecture, you will be able to generate a CronJob manifest with --dry-run=client -o yaml and apply it using the hybrid approach.
- CronJob - Jobs History Limits2:24
After this lecture, you will be able to configure successfulJobsHistoryLimit and failedJobsHistoryLimit to control how many completed and failed Jobs are retained.
- CronJob - Creating a Job from CronJob2:32
After this lecture, you will be able to manually create a Job from an existing CronJob using kubectl create job --from=cronjob.
- CronJob - Deleting a CronJob1:13
After this lecture, you will be able to delete a CronJob along with its Jobs and Pods using both imperative and declarative approaches.
- Role Play: Implementing Scheduled Maintenance with CronJobs
- Multi-container Pods - Overview2:57
After this lecture, you will be able to explain why a Pod might contain more than one container and list common multi-container use cases.
- Init Containers - Overview1:53
After this lecture, you will be able to explain how init containers run to completion before app containers start.
- Init Containers - Workflow1:31
Explore the pod startup workflow from API server assigning a node to scheduler and kubelet, which then starts unit containers and finally launches main containers after unit completion.
- Init Containers - Key Properties1:32
After this lecture, you will be able to identify the key properties of init containers, including ordering, completion requirement, and lack of health probe support.
- Init Containers - Use Cases3:53
After this lecture, you will be able to configure init containers to add a startup delay or wait for a dependent service before the main container starts.
- Init Containers - Demo4:25
Configure an init container for a main container in Kubernetes using a declarative manifest. Use a busybox init container to sleep before the main container starts in the initpod pod.
- Init Containers - Targeting a Specific Container in a Pod - Exam Tips5:10
After this lecture, you will be able to target a specific container in a multi-container Pod using the --container (-c) flag with exec and logs.
- Init Containers - Documentation Reference2:39
Refer to the Kubernetes docs to configure init containers in a pod, review example configurations, and apply the shown command patterns that run init containers before the main container.
- Sidecar Containers - Overview1:46
After this lecture, you will be able to explain how sidecar containers extend the main container's functionality without modifying it.
- Sidecar Containers - Workflow2:04
Explore the sidecar workflow in a pod, showing how the scheduler, kubelet, and main and sidecar containers start in parallel and share data via a shared volume.
- Sidecar Containers - Key Properties0:55
After this lecture, you will be able to identify the key properties of sidecar containers, including shared volumes and independent lifecycles.
- Sidecar Containers - Use Cases2:54
After this lecture, you will be able to design sidecar containers for logging and metrics use cases using shared volumes.
- Sidecar Containers - Demo5:08
After this lecture, you will be able to configure a sidecar container that reads data written by the main container through a shared volume.
- Sidecar Containers Can Be Init Containers - Tips0:29
- Adapter Containers - Overview1:39
After this lecture, you will be able to explain how an adapter container transforms a main container's output into a format expected elsewhere.
- Adapter Containers - Workflow1:50
After this lecture, you will be able to apply the adapter pattern to standardize metrics, reformat logs, or integrate legacy application interfaces.
- Adapter Containers - Use Cases2:12
Use the adapter pattern to standardize metrics and logs by transforming data into formats like Prometheus, and to modernize legacy apps or expose new APIs without altering the main application.
- Ambassador Containers - Overview1:25
After this lecture, you will be able to explain how an ambassador container proxies communication between the main container and external services.
- Ambassador Containers - Workflow1:32
Explore the ambassador container workflow in Kubernetes, where the main and ambassador containers start in parallel under the kubelet, with the ambassador proxying database connections.
- Ambassador Containers - Use Cases1:24
After this lecture, you will be able to identify ambassador container use cases including database sharding, service discovery, connection pooling, and authentication proxying.
- Multi-container Pods - Exam Tips1:34
After this lecture, you will be able to recall how init, sidecar, adapter, and ambassador containers are configured differently under initContainers versus containers in a manifest.
- Health Probing - Overview1:51
After this lecture, you will be able to explain why health probing matters for maintaining application availability and performance.
- Health Probing - Types of Health Probes6:57
After this lecture, you will be able to distinguish between liveness, readiness, and startup probes and describe when each is used.
- Health Probing - Dependency Between Health Probes1:35
After this lecture, you will be able to explain the order in which startup, liveness, and readiness probes run relative to each other.
- Health Probing - Probe Check Mechanisms3:51
After this lecture, you will be able to configure exec, HTTP GET, TCP socket, and gRPC probe check mechanisms.
- Health Probing - Common Probe Attributes4:48
After this lecture, you will be able to configure common probe attributes including periodSeconds, initialDelaySeconds, timeoutSeconds, successThreshold, and failureThreshold.
- Health Probing - Common Probe Attributes Workflow2:56
Explore the liveness probe workflow using http get, covering initial delay, period seconds, success threshold, timeout seconds, and failure threshold, and how the container restarts after repeated failures.
- Health Probing - Probing Configuration in System Components3:52
Explain how Kubernetes system manifests configure health probing with liveness, readiness, and startup probes using HTTP GET to live-z and ready-z on port 10259, with delays, timeouts, and failure thresholds.
- Health Probing - Configuring a Execute Command Probe4:17
Configure a readiness probe with an exec command in a Kubernetes nginx pod, defining initial delay, period, retry, and timeout, then validate the YAML with a dry-run before applying.
- Health Probing - Configuring a HTTP GET Probe3:21
After this lecture, you will be able to configure a liveness probe using the HTTP GET mechanism and verify its status with kubectl describe.
- Deployments - Core Concepts and Features1:47
After this lecture, you will be able to list the deployment strategies available for a Deployment, including rolling update, blue/green, canary, and scaling.
- Rolling Updates - Understanding the Basics7:35
After this lecture, you will be able to explain how Kubernetes controls pod availability and surge during a rolling update using maxUnavailable and maxSurge.
- Rolling Updates - Creating Your First Deployment - Demo Part 12:21
After this lecture, you will be able to use kubectl rollout commands to view history, pause, resume, restart, and check the status of a Deployment rollout.
- Rolling Updates - Deploying a New Version - Demo Part 22:42
After this lecture, you will be able to use kubectl rollout commands to view history, pause, resume, restart, and check the status of a Deployment rollout.
- Rolling Updates - Monitoring Deployment Progress - Demo Part 32:47
After this lecture, you will be able to use kubectl rollout commands to view history, pause, resume, restart, and check the status of a Deployment rollout.
- Rolling Updates - Performing Rollbacks - Demo Part 43:56
After this lecture, you will be able to use kubectl rollout commands to view history, pause, resume, restart, and check the status of a Deployment rollout.
- Blue-Green Deployment - Overview3:24
After this lecture, you will be able to explain the blue-green deployment model, including its two environments and traffic-switching process.
- Blue-Green Deployment - Workflow1:44
After this lecture, you will be able to explain the workflow of a blue-green deployment.
- Blue-Green Deployment - Pros and Cons1:45
After this lecture, you will be able to weigh the pros and cons of blue-green deployments, including zero-downtime switching against double resource cost.
- Blue-Green Deployment - Setting Up Initial Environment - Demo Part 14:06
After this lecture, you will be able to set up the initial environment for a blue-green deployment.
- Blue-Green Deployment - Configuring Service Routes - Demo Part 21:43
After this lecture, you will be able to configure the service routes for a blue-green deployment.
- Blue-Green Deployment - Implementing New Version - Demo Part 31:25
After this lecture, you will be able to implement the new version for a blue-green deployment.
- Blue-Green Deployment - Traffic Migration Strategy - Demo Part 41:10
After this lecture, you will be able to implement the traffic migration strategy for a blue-green deployment.
- Blue-Green Deployment - Cleanup and Verification - Demo Part 52:38
Verify the green deployment by accessing the nginx service from a temporary pod, then scale the blue deployment to zero to clean up and route traffic to green pods.
- Canary Deployment - Overview2:21
After this lecture, you will be able to cleanup and verify the blue-green deployment.
- Canary Deployment - Workflow2:38
After this lecture, you will be able to explain the canary deployment model, including gradual traffic shifting from the old to the new version.
- Canary Deployment - Pros and Cons1:38
After this lecture, you will be able to weigh the pros and cons of canary deployments, including reduced risk against added complexity.
- Canary Deployment - Setting Up Production Environment - Demo Part 12:50
After this lecture, you will be able to set up the production environment for a canary deployment.
- Canary Deployment - Configuring Service Distribution - Demo Part 20:50
After this lecture, you will be able to configure the service distribution for a canary deployment.
- Canary Deployment - Introducing Test Version - Demo Part 33:00
After this lecture, you will be able to introduce the test version for a canary deployment.
- Canary Deployment - Progressive Traffic Shifting - Demo Part 41:33
After this lecture, you will be able to implement the progressive traffic shifting for a canary deployment.
- Deployment Strategies - Blue/Green vs Canary3:18
After this lecture, you will be able to compare blue-green and canary deployments by traffic distribution, resource usage, rollout speed, risk, and complexity.
- Kubernetes Scaling - Manual Scale-Up Operations - Demo Part 13:32
After this lecture, you will be able to manually scale up a deployment.
- Kubernetes Scaling - Manual Scale-Down Operations - Demo Part 21:42
After this lecture, you will be able to manually scale down a deployment.
- Kubernetes Scaling - Implementing HorizontalPodAutoscaler (HPA) - Demo Part 34:01
After this lecture, you will be able to implement the HorizontalPodAutoscaler for a deployment.
- Helm - Overview and Installation5:43
After this lecture, you will be able to explain Helm's repository, chart, and release concepts and identify ways to install Helm.
- Helm - Repository Management4:39
After this lecture, you will be able to manage the repositories for a Helm release.
- Helm - Install and Uninstall Operations6:29
After this lecture, you will be able to install and uninstall a Helm release.
- Helm - Upgrade and Rollback Operations6:17
After this lecture, you will be able to upgrade a Helm release with custom values or a specific chart version, view its history, and roll it back to a prior revision.
- Kustomize - Overview3:57
After this lecture, you will be able to explain how Kustomize composes, generates, and customizes Kubernetes resources without templating.
- Kustomize - Composing Resources7:12
After this lecture, you will be able to compose resources for a Kustomize release.
- Kustomize - Generating Resources4:27
After this lecture, you will be able to generate resources for a Kustomize release.
- Kustomize - Setting Cross-cutting Fields5:06
After this lecture, you will be able to set the cross-cutting fields for a Kustomize release.
- Kustomize - Removing the Resources1:55
After this lecture, you will be able to remove the resources for a Kustomize release.
- Kustomize Configuration Files - Implicit vs Explicit Metadata - Tips0:36
- Overview of Kubernetes Configuration3:28
After this lecture, you will be able to explain how ConfigMaps and Secrets decouple configuration data from a Pod's lifecycle.
- ConfigMap - Overview4:03
After this lecture, you will be able to identify the structure of a ConfigMap manifest and its key-value data format.
- ConfigMap - Creating using Imperative Approach - Literal Values3:39
After this lecture, you will be able to create a ConfigMap imperatively from literal key-value pairs using --from-literal.
- ConfigMap - Creating using Imperative Approach - Environment File2:18
After this lecture, you will be able to create a ConfigMap imperatively from an environment file using --from-env-file.
- ConfigMap - Creating using Imperative Approach - Configuration File2:36
After this lecture, you will be able to create a ConfigMap imperatively from a configuration file using --from-file, storing the whole file under one key.
- ConfigMap - Creating using Imperative Approach - Directory1:17
After this lecture, you will be able to create a ConfigMap imperatively from all files in a directory using --from-file.
- ConfigMap - Creating using Declarative Approach3:29
After this lecture, you will be able to create a ConfigMap declaratively from a YAML manifest containing both property-like and file-like keys.
- ConfigMap - Consuming Approaches4:57
After this lecture, you will be able to identify the three ways to consume a ConfigMap in a Pod: as environment variables via envFrom or env, or as a mounted volume.
- ConfigMap - Consuming as Environment Variable0:44
After this lecture, you will be able to consume a ConfigMap as an environment variable.
- ConfigMap - Consuming as Volume4:12
After this lecture, you will be able to consume a ConfigMap as a volume.
- Secret - Overview6:27
After this lecture, you will be able to explain how Secrets store sensitive data, describe their manifest structure, and list the imperative and declarative ways to create them.
- Secret - Creating using Imperative Approach - Literal Values3:54
After this lecture, you will be able to create a Secret imperatively from literal key-value pairs using --from-literal.
- Secret - Creating using Imperative Approach - Environment file2:17
Create Kubernetes secrets imperatively from an environment file, encoding values automatically, by kubectl create secret generic secret-from-environment-file with app.config.environment, containing username and password, and view data in YAML format.
- Secret - Creating using Imperative Approach - Configuration file3:14
After this lecture, you will be able to create a Secret imperatively from a configuration file using --from-file.
- Secret - Creating using Imperative Approach - Directory1:26
After this lecture, you will be able to compare Secrets and ConfigMaps by sensitivity, node distribution, and pod access restrictions.
- Secret - Creating using Declarative Approach4:43
After this lecture, you will be able to create a Secret declaratively from a YAML manifest containing both property-like and file-like keys.
- Secret - Consuming as Environment Variable4:23
After this lecture, you will be able to consume a Secret as an environment variable.
- Secret - Consuming as Volume3:46
After this lecture, you will be able to consume a Secret as a volume.
- Secret - Secret vs ConfigMap2:32
After this lecture, you will be able to compare Secrets and ConfigMaps by sensitivity, node distribution, and pod access restrictions.
- Service - Introduction and Core Concepts4:31
After this lecture, you will be able to explain why Services are needed to provide stable access to ephemeral Pods.
- Service - Networking Model Deep Dive5:10
After this lecture, you will be able to describe the container-to-container, Pod-to-Pod, Pod-to-Service, and external-to-Service communication models.
- Service - Configuration and Key Fields3:00
After this lecture, you will be able to identify the selector, ports, and type fields that configure a Service.
- Service - Types and Use Cases7:02
After this lecture, you will be able to distinguish between ClusterIP, NodePort, LoadBalancer, and ExternalName Service types and their use cases.
- Service - Creating Kubernetes Services - Demo Part 16:14
After this lecture, you will be able to expose an existing Deployment as a ClusterIP Service using kubectl expose.
- Service - Creating and Exposing Services Simultaneously - Demo Part 22:18
After this lecture, you will be able to create a Pod and expose it as a Service simultaneously using kubectl run with --expose and --port.
- Service - Defining Services Imperatively - Demo Part 33:53
After this lecture, you will be able to create a Service from scratch imperatively using kubectl create service.
- Service - Defining Services Declaratively - Demo Part 41:59
After this lecture, you will be able to create a Service declaratively from a YAML manifest.
- Service - Updating Service Configuration4:14
After this lecture, you will be able to update the configuration of a Service.
- Service - Working with Endpoints and EndpointSlices7:42
After this lecture, you will be able to inspect Endpoints and EndpointSlices to see how a Service maps to backing Pod IPs and ports.
- Service - Deleting Resources1:50
After this lecture, you will be able to delete the resources for a Service.
- Kubernetes Networking - Ingress vs Gateway API1:01
After this lecture, you will be able to explain the current status of the Ingress API and why the Gateway API is emerging as its successor.
- Ingress - Understanding Ingress and Ingress Controller7:20
After this lecture, you will be able to describe Ingress path types, rules, and the role of an Ingress controller in fulfilling Ingress resources.
- Ingress - Creating and Managing Ingress Resources5:47
After this lecture, you will be able to create and manage Ingress resources.
- Network Policies - Introduction and Core Concepts6:07
After this lecture, you will be able to explain how NetworkPolicies restrict traffic between Pods, namespaces, and IP addresses.
- Network Policies - Manifest Structure6:25
After this lecture, you will be able to identify the podSelector, policyTypes, ingress, and egress fields of a NetworkPolicy manifest.
- Network Policies - Core Components and Rules8:30
After this lecture, you will be able to select traffic sources and destinations using podSelector, namespaceSelector, and ipBlock in a NetworkPolicy.
- Network Policies - Common Use Cases and Patterns4:33
After this lecture, you will be able to write NetworkPolicies for common patterns including default-deny, allow-all, and combined ingress/egress rules.
- Network Policies - Implementation Demo9:39
After this lecture, you will be able to implement a NetworkPolicy for a deployment.
- Volumes - Overview4:11
After this lecture, you will be able to explain how volumes let containers in a Pod share and persist data beyond a single container's lifetime.
- Volumes - Types of Volumes2:40
After this lecture, you will be able to distinguish ephemeral volume types like emptyDir, configMap, and secret from persistent types like hostPath, local, nfs, and csi.
- Volumes - Volume Configuration in System Components4:28
After this lecture, you will be able to configure volumes in system components.
- Volumes - Configuring a Pod with Volume7:03
After this lecture, you will be able to configure a Pod with two containers sharing data through an emptyDir volume.
- Persistent Volumes - Introduction to Persistent Storage4:05
After this lecture, you will be able to explain how the PersistentVolume subsystem abstracts storage provisioning from storage consumption.
- Persistent Volumes - Understanding PersistentVolumes3:54
After this lecture, you will be able to describe a PersistentVolume's characteristics and the difference between static and dynamic provisioning.
- Persistent Volumes - Essential Properties1:53
After this lecture, you will be able to configure a PersistentVolume's storage class name, capacity, and volume mode.
- Persistent Volumes - Access Modes1:34
After this lecture, you will be able to distinguish between ReadWriteOnce, ReadOnlyMany, ReadWriteMany, and ReadWriteOncePod access modes.
- Persistent Volumes - hostPath Volumes and Access Modes0:40
After this lecture, you will be able to configure a hostPath volume and its access modes.
- Persistent Volumes - Reclaim Policies1:23
After this lecture, you will be able to distinguish between the Retain and Delete reclaim policies for a PersistentVolume.
- Persistent Volumes - Understanding PersistentVolumeClaims4:37
After this lecture, you will be able to explain how a PersistentVolumeClaim requests storage and how its storageClassName affects PV binding.
- Persistent Volumes - Lifecycle of Persistent Storage2:12
After this lecture, you will be able to describe the provisioning, binding, using, and reclaiming stages of a PersistentVolume's lifecycle.
- Persistent Volumes - Demo - #1 Create PersistentVolume (PV)4:56
After this lecture, you will be able to create a PersistentVolume from a manifest and verify its status is Available.
- Persistent Volumes - Demo - #2 Create PersistentVolumeClaim (PVC)2:31
After this lecture, you will be able to create a PersistentVolumeClaim that binds to a matching PersistentVolume and verify its status is Bound.
- Persistent Volumes - Demo - #3 Mount PVC to Pod4:25
After this lecture, you will be able to mount a PersistentVolumeClaim into a Deployment and verify data persists across Pod recreation.
- Persistent Volumes - Upgrading Resource Consumption - Exam Tips0:41
Upgrade the resource limits of persistent volumes by updating the manifest, then wait a few seconds and recheck kubectl output to confirm the changes for the CKAD exam.
Requirements
- Working knowledge of the container runtime.
- Basic Linux command line skills (file operations, text editing).
- Familiarity with YAML syntax (helpful but not mandatory).
Description
Welcome to the CKAD (Certified Kubernetes Application Developer) course! This comprehensive course is designed to prepare you for the CKAD certification exam, which focuses on developing, deploying, and debugging cloud-native applications for Kubernetes.
Whether you're a developer looking to build applications on Kubernetes or an IT professional seeking to enhance your container orchestration skills, this course will equip you with the practical knowledge and hands-on experience needed to pass the certification exam.
CKAD Exam Domains Covered In This Course:
Application Design and Build (20%)
Define, build, and modify container images
Choose and use the right workload resource (Deployment, DaemonSet, CronJob, etc.)
Understand multi-container Pod design patterns (e.g., sidecar, init, and others)
Utilize persistent and ephemeral volumes
Application Deployment (20%)
Use Kubernetes primitives to implement common deployment strategies (e.g., blue/green or canary)
Understand Deployments and how to perform rolling updates
Use the Helm package manager to deploy existing packages
Kustomize
Application Observability and Maintenance (15%)
Understand API deprecations
Implement probes and health checks
Use built-in CLI tools to monitor Kubernetes applications
Utilize container logs
Debugging in Kubernetes
Application Environment, Configuration, and Security (25%)
Discover and use resources that extend Kubernetes (CRD, Operators)
Understand authentication, authorization, and admission control
Understand requests, limits, and quotas
Understand ConfigMaps
Define resource requirements
Create & consume Secrets
Understand ServiceAccounts
Understand Application Security (SecurityContexts, Capabilities, etc.)
Services and Networking (20%)
Demonstrate basic understanding of NetworkPolicies
Provide and troubleshoot access to applications via services
Use Ingress rules to expose applications
What You'll Achieve
Practical Kubernetes Skills: Develop real-world applications that run on Kubernetes clusters.
Exam Readiness: Master all CKAD exam domains with hands-on practice.
Industry Recognition: Earn the globally recognized CKAD certification.
Career Advancement: Position yourself for roles in cloud-native development.
Course Features
Exam-focused Content: Aligned with current CKAD exam objectives.
Exam Tips: Quick tips to help you perform better in the exam.
Practical Examples: Real-world scenarios and use cases.
CKAD Exam Info
Duration: 2 hours
Format: Performance-based (hands-on)
Questions: 15-20 tasks to complete
Passing Score: 66%
By the end of this course:
You'll have a solid foundation in developing, deploying, and debugging cloud-native applications for Kubernetes.
You will gain the necessary knowledge to pass the CKAD exam and earn the Certified Kubernetes Application Developer certification.
Enroll now and start your journey toward becoming a Certified Kubernetes Application Developer!
Who this course is for:
- Application Developers wanting to build cloud-native applications.
- DevOps Engineers looking to enhance their container orchestration skills.