CKAD Certified Kubernetes Application Developer [2026]

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.

Explore practical options to set up a Kubernetes cluster for CKAD exam prep, from Docker Desktop and Minikube to kind and k3s, plus cloud sandboxes like Killer Coda.

Discover basic SSH usage to connect to Kubernetes exam nodes, run commands like kubectl get nodes, and return to the main session, including single-shot SSH executions.

Kubectl is the gateway to the Kubernetes API server, wrapping HTTP requests into a CLI for cluster interaction and illustrating commands, subcommands, resource types, and flags like -n and -o.

Explore essential kubectl commands for Kubernetes, including version, cluster-info, api resources, shorthand notations such as po and pvc, and how to use explain and help options.

Master terminal efficiency for the CKAD exam by using shift-ctrl shortcuts for copy-paste, managing multiple kubectl terminals, and optimizing a two-pane task and terminal layout, with zoom and sizing steps.

Learn vim essentials for Kubernetes exam tasks, including editing YAML manifests, navigating, saving, quitting, copying and pasting, indenting, undoing, searching, and applying changes with kubectl.

Explore the Kubernetes architecture, distinguishing the control plane and worker nodes, and how the API server, scheduler, HCD database, and controllers coordinate workloads through kubelet, container runtime, and kube proxy.

Explore the control plane's core components, including the API server, HCD database, kubescheduler, and kube-controller suite, to learn how Kubernetes deploys, schedules, and self-heals clusters.

Discover how worker nodes host pods and run containers, with kubelet coordinating pod lifecycles via the API server, while kubeproxy handles networking, services, and the container runtime executes workloads.

Explore how containers package apps with runtime, dependencies, and configurations into portable units, and how Kubernetes orchestrates them with runtimes like Docker and ContainerD for consistent cloud-native deployments.

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.

Explore how a Dockerfile builds a container image from a base image using instructions and caching, with a Python app example and tips on slim base images and minimal layers.

Build and manage container images with Docker image build, tag, and list commands, while understanding Docker client, server, and API versions and build context.

Learn to run docker containers and manage images using docker container run. Explore foreground and detached modes, container naming, and essential troubleshooting commands like logs and inspect.

Learn to distribute docker images by logging into Docker Hub, tagging images with the user and version (codewithpravin/app:1.0 and 2.0), pushing and pulling, and running containers to verify updates.

Explore Kubernetes object management through imperative kubectl approaches, declarative yaml manifests, and hybrid method, with emphasis on when to use each to create pods, deployments, services, config maps, and secrets.

Master the imperative approach to Kubernetes using kubectl to create and manage pods, deployments, and services. Assess its immediate feedback and speed versus non-repeatable, limited configurations to guide method choice.

Discover how declarative yaml manifests define the desired state in Kubernetes, applied with kubectl, using three-way merge and last-applied configuration to manage spec and status.

Explore the Kubernetes hybrid approach that combines imperative manifest generation with declarative application. Generate a YAML via dry-run, edit it, then apply to manage resources.

Explore when to use imperative, declarative, or hybrid approaches in Kubernetes object management, with exam tips on quick actions, tweaking existing manifests, and custom configurations.

Explore Kubernetes nodes—physical or virtual machines that run containers—distinguish control plane and worker nodes, and inspect their roles, IPs, and runtime with kubectl get nodes.

Define how namespaces provide a scope for Kubernetes resources, enabling isolation and access control. Distinguish built-in versus user-defined namespaces, including default, kube-system, kube-public, and kube-node-lease, for organizing cluster resources.

Create and manage Kubernetes namespaces using kubectl commands, including create, get, describe, and get -o yaml to view metadata and configuration.

Assign kubernetes resources to specific namespaces by creating pods in staging and production with kubectl -n, observe default namespace behavior, and use -A to list across all namespaces.

Explore Kubernetes labels as key-value tags used to identify, organize, and query resources with kubectl, using environment, app, version, and team labels to group resources.

Apply labels to Kubernetes resources using kubectl label, assigning key-value pairs such as environment and frontend to pods and deployments during or after creation, and bulk-labeling all pods in namespace.

Learn how to manage kubectl labels on pods by updating a label with --overwrite, removing a label with a trailing dash, and viewing all labels with --show-labels.

Explore label selectors in Kubernetes, using labels to tag pods and identify resources via equality-based and set-based selectors with kubectl and manifest-based queries.

Learn how to filter Kubernetes resources with set-based label selectors using in, not in, and exist operators. Combine set-based and equality-based selectors to refine pod queries with kubectl.

Use equality-based selectors to filter pods by label matches with equals and not equals operators, and apply single or multiple label conditions with kubectl -l; or conditions use set-based selectors.

Explore equality-based and set-based label selectors in kubectl and yaml manifest files, and see how services expose pods by matching environment=production via the selector.

Explore tips for using labels and label selectors in Kubernetes exams, including single-quote syntax for set-based selectors, comma-separated conditions, and the show labels flag for troubleshooting.

Explore how annotations in Kubernetes store non-identifying metadata as key-value pairs, unlike labels used for object selection; capture build details, contact information, ownership, and configuration notes to aid developers.

Apply annotations with kubectl annotate to resources by type and name using key value pairs, including during creation with --annotations and bulk across production parts with --all.

Manage annotations on resources by updating, removing, and viewing them with kubectl. Learn to update with the overwrite flag, remove a key, and verify changes via describe.

Compare labels and annotations in Kubernetes: labels identify resources and enable selection via label selectors. Annotate resources with metadata and documentation using annotations, which are not queryable.

Explore pods as the fundamental Kubernetes resource, a container collection with shared storage and network, usually a single container per pod for real-world apps.

Explore the pod manifest structure in Kubernetes, including apiVersion, kind, metadata, and spec with containers. Illustrates an nginx pod and highlights YAML as the preferred manifest format.

Create pods using the imperative approach with kubectl run, verify with kubectl get pods, and inspect details via kubectl describe for Kubernetes exams.

Create a pod using the declarative approach by defining a YAML manifest and applying it with kubectl -f. See the nginx-declarative pod running to compare declarative and imperative methods.

Create a pod with a hybrid approach by generating a yaml via kubectl run --dry-run -o yaml, then deploying it with kubectl apply -f.

Explore the pod lifecycle in Kubernetes, detailing pending, running, succeeded, failed, and unknown phases, how pods can die and spawn new instances via the scheduler and node.

Explore two ways to execute commands in a container: imperative kubectl exec from the terminal, and declarative commands in the pod manifest, with practical exam-focused tips.

Practice the kubectl exec pattern with the pod name, separator, bin shell, -c and your command, both in the terminal and in manifests, to save time on the CKAD exam.

Delete a pod in Kubernetes using imperative and declarative approaches. Use kubectl delete pod <name> or kubectl delete -f <yaml> to remove it, with --force and --grace-period=0 for immediate deletion.

Explore ReplicaSet in Kubernetes and learn how it maintains a specified number of pod replicas, creates or replaces pods as needed, and schedules them across nodes.

Explore the replica set manifest structure, including api version apps/v1, kind replica set, metadata, replicas, selector, and the pod template that maintains desired pods.

Create Kubernetes replica sets declaratively by editing and reusing manifest templates, then apply with kubectl and verify with get commands, while understanding rs naming conventions and pod templates.

Delete a replica set using kubectl, with rs shorthand or the replica set keyword, and optionally remove via a manifest file with -f, ensuring all parts are gone.

Explore how deployments manage replica sets and pods (POTs), enable rolling updates and rollbacks, and scale with horizontal pod autoscalers, with reference to the Kubernetes docs for manifests.

Explore the deployment manifest structure in Kubernetes, including API version apps/v1, kind deployment, metadata, spec with replicas, selector and pod template, and a concrete nginx deployment example.

Learn to create Kubernetes deployments with imperative approach using kubectl create deploy, specify replicas, and inspect with kubectl get deploy and kubectl describe, revealing deployment, replica set, and pod relationships.

Use a hybrid deployment approach with kubectl by generating a yaml manifest via dry run, applying it declaratively, and verifying with get deploy and get pods.

Apply labels to deployments with kubectl label after creating the deployment, since kubectl create-deploy lacks the dash-dash-labels flag. Verify with kubectl get-deploy --show-labels to confirm environment=staging labeling.

Delete a deployment in Kubernetes using both imperative (kubectl delete deploy name) and declarative (kubectl delete -f file) approaches, then verify with kubectl get deploy and kubectl get all.

Explore the StatefulSet resource in Kubernetes, showing how it manages stateful apps with DNS and IP per pod, stable storage via persistent volume claims, and ordered deployment and rolling updates.

Create and understand a stateful set in Kubernetes from a manifest or from scratch, including sts components, a headless service with cluster IP none, and DNS-based access to web0–web2.

Compare stateful sets and deployments by examining headless services, persistent volume claims, pod identity, and deployment order to reveal when to use for databases versus web apps.

Deploy a daemon set to run a single pod on every node, enabling node-level logging, metrics monitoring, and network components such as kube-proxy and flannel.

Create a daemon set in Kubernetes using a declarative manifest, nginx-ds.yml, to deploy an nginx pod on every node. Use kubectl to manage and inspect the daemon set and pods.

Delete a daemon set in Kubernetes by verifying pods are running, then deleting via kubectl, either using the command or a declarative yaml file, and confirm pods are removed.

Explore how Kubernetes jobs run one-off tasks to completion by creating pods, with restart policies, batch/v1 manifests, and pod templates; see imperative, declarative, and hybrid creation methods.

Learn to create a Kubernetes job using the imperative approach with kubectl create job, define the pod container and command, and verify the job and its pod status.

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.

Master the hybrid approach to creating Kubernetes jobs by generating a YAML manifest with a dry-run, then applying it to deploy a job and monitor its completion.

Master the Kubernetes job lifecycle attributes: backoff limit, completions, and parallelism. See how retries and concurrent pods decide when a job completes, with default values and a YAML example.

Delete a Kubernetes job using imperative kubectl delete job or declarative -f yaml, then verify removal with kubectl get and learn comma-separated type listing for multi-resource checks.

Explore how Kubernetes cron jobs schedule and manage recurring jobs by creating pods and containers, retrying on failure, and enabling tasks like backups and log cleanup at set intervals.

Explore the cron job manifest structure, built on the job and pod layers, with schedule and templates. View an example using a busybox pod, its command, and on-failure restart policy.

Understand the cron pattern in cron jobs for repeats. Apply minute, hour, day, month, and weekday settings with examples like daily at 2 a.m., every 15 minutes, and weekdays 1-5.

Learn how to create a Kubernetes cron job with an imperative approach using kubectl create-cron-job, including setting the schedule, understanding the resulting job and pod, and naming conventions.

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.

Learn to create a cron job using a hybrid approach that combines imperative commands with a declarative manifest applied via kubectl, using dry-run to generate yaml for the schedule.

Manage cron job history in Kubernetes by setting successful and failed jobs history limits; defaults keep the last three successful jobs and one failed job.

Learn how to create a Kubernetes job from a cron job using kubectl create-job --from=cronjob, illustrated with a print-date-cj-cronjob, and verify with kubectl get-cronjobs and logs.

Explore deleting cron jobs via imperative and declarative approaches using kubectl delete by name or by manifest file, then run get to confirm cron jobs and related parts are removed.

Master multi-container pods in Kubernetes by showing how a pod can run multiple containers that share network and storage. Identify init, sidecar, adapter, and ambassador containers and their roles.

Explore init containers in Kubernetes, which run before app containers in a multi-container pod, ensuring sequential execution and starting main containers only after successful init containers.

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.

Understand Kubernetes init containers, which always complete before the main container starts, lack health checks, execute sequentially when multiple are defined, and restart the pod if any fail.

Explore common init container use cases in Kubernetes, including delaying the main app, waiting for a service, and generating config files on a shared volume before startup.

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.

Use kubectl -c to target a specific container in a pod, defaulting to the main container when omitted, and understand init containers in log and command scenarios.

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.

Explore sidecar containers in Kubernetes, which extend the main container with helper functionality, share volumes, and support the main container without handling its core logic in a pod.

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.

Explore sidecar containers and properties, including health probes like liveness, readiness, and startup checks, how they share data with the main container via shared volumes, and their lifecycle and resources.

Explore sidecar containers in Kubernetes and how they run alongside the main app to enable logging with a shared log-storage volume and standardized monitoring via Prometheus.

Demonstrate sidecar containers in Kubernetes with a two-container pod using a shared emptyDir volume to write and read date.txt, then validate and clean up with kubectl.

Explore adapter containers in Kubernetes, a multi-container pod pattern that reads data from a container and transforms it from one format to the format required by a target application.

Describe the adapter container workflow in Kubernetes, where the pod runs main and adapter containers in parallel to transform and expose data to external systems.

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.

Explore the ambassador container pattern as a proxy that connects the main application to external services, handling service discovery, connection management, encryption, and authentication before routing requests.

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.

Explore ambassador containers in Kubernetes multi-container pods, covering use cases like database sharding with routing, service discovery with load balancing, connection pooling, and authentication.

Distinguish unit containers, used to initialize, from sidecar, adapter, and ambassador types in multi-container pods; unit containers use a separate field and no volumes, while others use containers with volumes.

Explore health probing in Kubernetes, including readiness and liveness checks to keep pods available and running. Detect issues like memory leaks and deadlocks during startup and maintenance, and tune performance.

Explore the three Kubernetes health probes—liveness, readiness, and startup—and how kubelet uses them to restart unhealthy containers, gate traffic, and sequence startup before checks.

Explore how startup probes gate the liveness and readiness probes, which run in parallel only after startup succeeds and continue to be monitored by the kubelet for the pod's lifetime.

Explains the four health probes in Kubernetes—execute, HTTP GET, TCP socket, and gRPC—and how to configure them for readiness, liveness, and startup probes, with HTTP GET being most common.

Configure Kubernetes health probes by adjusting initial delay seconds, period seconds, timeout seconds, and success and failure thresholds for liveness, readiness, and startup checks using HTTP GET examples.

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.

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.

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.

Configure a Kubernetes liveness probe with HTTP GET for nginx on root port 80, with initial delay 15 seconds and period 10 seconds, alongside the readiness probe.

Learn how Kubernetes deployments manage replica sets and pods across nodes in a cluster, and apply strategies like rolling updates, blue-green, canary, and scaling to ensure availability.

Learn rolling updates in Kubernetes to upgrade deployments from v1 to v2, with replica sets, max surge and max unavailable, triggering rollouts via pod template changes and kubectl set image.

Master rolling updates in Kubernetes by creating an initial deployment, rolling out a newer version, monitoring the rollout, and rolling back if needed, via kubectl and deployment YAML.

Trigger rolling updates by using kubectl set image to upgrade a deployment's container from 1.24 to 1.26, or edit the deployment manifest with kubectl edit deploy.

Monitor deployment rollouts with kubectl rollout using status, history, undo, pause, restart, and resume commands for nginx deploy. Check rollout status and review revision history, including image version 1.26.

Learn to rollback a Kubernetes rollout with kubectl rollout undo, use --to-revision to jump to a specific revision, and review rollout history to compare replica sets and pods.

Explore blue-green deployment in Kubernetes, creating two identical environments named blue and green, routing live traffic via a service, and enabling quick rollback by switching traffic back.

This lecture demonstrates the blue-green deployment workflow in Kubernetes, showing how traffic shifts from the blue V1 to the green V2 after testing, with rollback options if needed.

Blue-green deployment enables zero downtime updates by routing traffic to the green version after testing, with rollback via the service manifest, but doubles resources and uses all-or-nothing traffic.

Implement a blue-green deployment in Kubernetes to achieve zero downtime by deploying blue (1.24), wiring a service to it, then deploying green (1.26) and switching traffic.

configure a service to route traffic to the blue deployment using selectors app nginx and version blue; use kubectl apply -f to create the service.

Demonstrates blue-green deployment by creating a green version to upgrade from v1 to v2, updating image to 1.26 and version label to green, and deploying with kubectl, three replicas.

Switch traffic in a blue-green deployment by updating the service manifest to green, reapplying with kubectl, and verifying the nginx-service now serves the green version.

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.

Explore canary deployment in Kubernetes, a parallel rollout where the new version runs with the old and traffic gradually shifts from v1 to v2.

Implement a canary deployment workflow by routing traffic between v1 and v2 through a service, starting with 100% to v1, then 20% to v2, monitor, and rollback if needed.

Deploy both versions and gradually increase traffic from 10% to 100%, enabling low-risk rollback. Expect complexity and slower rollout, and actively monitor old and new pods and resources.

Demonstrates canary deployment in Kubernetes by gradually shifting traffic from stable v1.24 to v1.26 with a service that splits traffic, and covers kubectl steps to deploy stable and canary versions.

Create and verify the nginx-service to monitor traffic by applying its manifest with kubectl, targeting the app equals nginx label via app-nginx, and confirming the selector remains unchanged.

Deploy a canary version with replicas=1, routing 25% of traffic to canary and 75% to stable. Verify by listing parts with label app nginx and applying manifest via kubectl apply.

Demonstrates progressive traffic shifting for a canary deployment by using kubectl scale to raise canary to two replicas and balance traffic to fifty percent for both canary and stable.

Compare blue-green and canary deployment strategies, highlighting all-or-nothing traffic in blue-green versus gradual canary traffic. Contrast resource use, rollout speed, risk, and complexity to help choose based on project requirements.

Explore how to scale Kubernetes deployments, manually adjusting replicas with kubectl scale and using horizontal pod autoscaler for auto scaling, demonstrated on an nginx deployment.

Scale down Kubernetes deployments by manually reducing replicas with kubectl scale deployment <name> --replicas <N>, triggering graceful termination of excess pods and updating the nginx deployment from four to two.

Explore implementing the horizontal pod autoscaler to automatically scale pods between a minimum and maximum, based on cpu usage, using kubectl autoscale and an nginx deploy example.

Learn how Helm, the package manager for Kubernetes, manages charts, repositories, and releases, and install it via scripts or OS package managers with practical examples.

Explore helm repository management by configuring and using Artifact Hub and Bitnami repositories, searching charts, adding repos, updating, and removing them for Kubernetes deployments.

Learn to install and uninstall Helm charts in a namespace, manage releases with custom values via set, and check status and list releases across namespaces.

Upgrade existing releases with Helm upgrade, optionally using --set for custom values and a target namespace, then rollback to a specific revision with Helm rollback after checking history.

Explore Kustomize as a standalone tool to customize Kubernetes resources—compose, generate, and apply cross-cutting fields like namespaces, labels, and annotations across deployments, services, and config maps.

Leverage kustomize to compose deployment and service resources with a customization.yml, apply patches, and deploy using kubectl apply -k.

Generate resources in your cluster with kustomize by using customization.yaml, leveraging config map generator and secret generator, then apply with kubectl apply -k, and disable name suffix hash.

Master Kustomize to apply cross-cutting fields across all resources using customization.yaml, including namespace, name prefix, labels, selectors, templates, and common annotations for deployments, services, config maps, and secrets.

Use kubectl delete -k to remove resources defined by a kustomize customization file in the frontend namespace, including config map, secret, service, and deployment.

Discover how Kubernetes uses config maps and secrets to manage configuration as key-value data, decoupled from pod lifecycles, consumable as env vars or volumes.

Explore ConfigMap in Kubernetes, storing configuration data as key-value pairs in a plain text, simple manifest with a data section, and compare imperative and declarative creation methods for exam readiness.

Create a config map from scratch using imperative approaches, starting with literal values. Use kubectl create with the cm shorthand to define and view plain text key–value pairs.

Create a config map using an environment file with key=value pairs, then pass the file to kubectl create config map --from-env-file, and list or view the result in yaml.

Create a config map from a generic configuration file using the imperative approach, storing the file content under appconfig.properties. An environment file turns each line into a key-value pair.

Create a Kubernetes config map using a declarative approach with a manifest file, then apply it with kubectl to define the data as key-value pairs in YAML.

Create a config map declaratively by using a manifest file, editing a sample YAML, and applying it with kubectl apply -f to deploy and verify the config map.

Configure a pod to consume a config map as environment variables using envFrom with configMapRef for the whole map, or env with valueFrom and configMapKeyRef for specific keys.

Configure config maps in pods by consuming them as environment variables or by mounting them as a volume, and learn which approach best fits your use case.

Mount a config map as a volume in a pod by defining the config volume and mounting it into the container, then verify app team and app version under hcconfig.

Kubernetes secrets store sensitive data as base64-encoded (not encrypted) key-value pairs, use the opaque type by default, and support environment variables or mounted volumes.

Create a Kubernetes secret imperatively using literal values with kubectl, choosing the opaque type and --from-literal for key value pairs, with data stored as base64 encoded values.

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.

Create a Kubernetes secret from a configuration file using kubectl --from-file, where the file name becomes the secret key and file contents are the encoded value, unlike environment file secrets.

Create Kubernetes secrets imperatively by passing a directory of files to kubectl, which builds a secret from files in that directory using the specified type and name.

Create a Kubernetes secret using a declarative manifest and apply it with kubectl apply -f. Encode the password in base64 within the data section and verify with kubectl get secrets.

Learn how to consume Kubernetes secrets in a pod manifest via environment variables or mounting as volumes, with practical steps using kubectl run, apply, and describe.

Mount a Kubernetes secret as a volume in a pod manifest, configure the secret name from literal, and mount it to the hc config path.

Learn the differences between secrets and config maps in Kubernetes: secrets store sensitive data and are pod-specific, while config maps hold non-sensitive data and are available to all pods.

Expose a group of pods with a Kubernetes service, providing a stable virtual IP and persistent endpoint using label selectors to simplify networking.

Explore Kubernetes networking across containers, pods, and services, including container-to-container, pod-to-pod, and pod-to-service communication. Learn how services expose pods with a cluster IP and enable external access.

Describe the Kubernetes service manifest structure, including api version v1, kind: service, and metadata, then explain how spec.selector, spec.ports, and spec.type control label-based port exposure and port targets.

Explore the four Kubernetes service types (cluster IP, node port, load balancer, external name) and their use cases for internal cluster communication, development testing, public facing apps, and external integrations.

Explore how to create and manage Kubernetes services using imperative and declarative approaches, including kubectl expose, run expose, create, and YAML manifests, and validate with deployment and service details.

Use kubectl run with the --expose flag and the port flag to create a deployment or pod and expose it as a service, defaulting to the pod name, cluster ip.

Learn to create Kubernetes services from scratch with kubectl create service, specify types such as cluster IP, external name, load balancer, or node port, and review selectors and service details.

Define a yaml manifest to create nginx-manifest-service with a declarative approach, using selector app-nginx, ports 80, cluster IP, and apply with kubectl.

Update a live Kubernetes service by editing its type from ClusterIP to NodePort with kubectl edit, then verify NodePort exposure and test access via node IP or ClusterIP.

Map a Kubernetes service to pod IPs using endpoints, and learn how endpoint slices scale endpoint sets into manageable groups. Endpoint slices replace endpoints for better scalability and automatic updates.

Delete Kubernetes services and deployments using imperative and declarative approaches with kubectl delete, including svc shorthand and deletion via -f files, and clean up endpoint slices and nginx-expose deployment.

Focus on Ingress for the CKAD exam while Gateway API is the future standard in Kubernetes networking and will gradually replace Ingress.

Expose cluster services to external clients using Ingress and an Ingress controller, routing HTTP traffic with host and path rules to backends, using exact or prefix path types.

Learn to create and manage Kubernetes ingress resources by deploying nginx, exposing it via a service, and configuring an nginx ingress with host nginx.example.com and a path prefix.

Learn how Kubernetes network policies use labels to control traffic between pods, namespaces, and external sources, acting as a firewall with ingress and egress rules.

Explain Kubernetes network policy manifest structure, including apiVersion, kind, and metadata. Define spec with podSelector, policyTypes, ingress, and egress, and show from and to options (pod, namespace, ipBlock) for traffic.

Explore core components of Kubernetes network policies and define ingress and egress rules using pod and namespace selectors, and ip block with cidr and except.

Explore common network policy use cases and patterns, including default deny for ingress. Understand how to configure fine-grained rules with port and namespace selectors for ingress and egress.

Demonstrates configuring network policy in a Kubernetes cluster using manifest examples, including pod selectors, ingress and egress rules, and default deny, plus testing connectivity between frontend and backend pods.

Explore volumes in Kubernetes to persist and share data among containers within a pod, covering creation, mounting in pod specs and containers, and multi-container access.

Explore Kubernetes volumes: ephemeral volumes and persistent volumes, and how pod lifetimes influence them. Recognize ephemeral options like empty directory, config map, secret; persistent options include host path and CSI.

Explore how Kubernetes defines and mounts volumes in core components like kubectl server and kube-scheduler, detailing the two-step process of volumes at the pod level and mounts in containers.

Configure a pod with a shared emptyDir volume and mounts so two containers write and read a timestamp file; writer writes every 30 seconds, reader reads every 60 seconds.

Learn how persistent volumes and persistent volume claims decouple storage from pods in Kubernetes, enabling cluster-wide, admin-managed storage that users can claim and mount to pods.

Explore persistent volumes in Kubernetes, including manual and dynamic provisioning via storage classes, and understand how PVs are cluster-scoped, manifest-created, and provisioned through PVCs.

Explore how persistent volumes rely on a storage class name for dynamic provisioning, with optional classless binding, defined capacity, and volume modes: file system (default) or block.

Learn to configure persistent volumes with the access modes in Kubernetes using spec.accessmodes. Kubernetes supports read-write-once, read-only-many, read-write-many, and read-write-once pod; choose the mode based on your application's needs.

Learn how Kubernetes reclaim policies determine what happens to persistent volumes after pods and claims are deleted, comparing retain and delete modes and their default behaviors.

Learn how persistent volumes are bound to persistent volume claims by matching storage class and properties, with PVCs being namespace scoped and created via manifests before mounting into pods.

Explore the lifecycle of persistent storage in Kubernetes: provisioning (static or dynamic), binding persistent volume claims to volumes, using storage in pod manifests, and reclaiming with retain or delete.

Create a persistent volume, then a persistent volume claim, and mount the claim to a pod using manifest files and kubectl, guided by Kubernetes documentation.

Create a persistent volume claim (PVC) that binds to a matching persistent volume. Use nginx-pvc.yaml with storage class manual and a 1gb request to ensure binding.

Bind a persistent volume claim to a pod and mount it to /user/share/nginx, deploy nginx, and verify data persists across pod restarts.

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.