Ultimate CKAD | Certified Kubernetes Application Developer

Build a three-node Ubuntu Kubernetes cluster on Google Cloud, install and configure Kubernetes, write YAML for pods, replica sets, and namespaces, and deploy a sample app to validate the cluster.

Explore the Kubernetes architecture overview, linking developer clusters to the control plane, master, and worker nodes that manage containerised apps running in ports and containers.

Explore the Kubernetes architecture in depth by detailing the master components—EPA, the persistent key-value store, the control manager, and CÉDULA—and the worker components—Kubelik, Q proxy, and container runtime.

Provision a three-node Kubernetes cluster on Google Compute Engine with Ubuntu 16.04, disable swap, ensure unique hostnames and MAC addresses, and configure firewall rules to enable secure node communication.

Learn to install a three-node Kubernetes cluster with kubeadm using docker as the container runtime and disable swap. Initialize the cluster, install kubectl, kubelet, configure Weave Net, and join workers.

Install Kubernetes with kubeadm in a hands-on demo, showcasing practical steps for deploying apps in a CKAD context.

Validate the Kubernetes cluster by confirming component versions and node readiness, then deploy a sample application to verify replicas, IP addresses, and networking across the master and two workers.

Experience a hands-on demo that shows how to validate Kubernetes infrastructure, aligned with ckad preparation and the certified Kubernetes application developer curriculum.

Experience a hands-on demo on connecting to a Kubernetes cluster, designed for the ultimate CKAD certification, to practice essential cluster access and setup concepts.

Demonstrate how to create a Google Kubernetes Engine cluster and deploy basic resources, aligning with the ckad certification goals.

Explore Kubernetes api primitives through the basic YAML object structure—api version, kind, metadata, and spec—comparing YAML with JSON and noting namespace and group concepts for deployments.

Pods are the smallest Kubernetes deployable units, wrapping one or more containers with a shared network namespace and resources, including a primary and supporting container with distinct ports.

Trace the end-to-end pods process flow from building and pushing a container image to a registry, writing YAML configurations, and deploying with deployments and services in the cluster.

Explore the pod life cycle from pending to running to succeeded or failed, as Kubernetes downloads images and resources, with deployments or replica sets recreating pods.

Explore creating a pod with a yaml configuration, covering api version, kind, metadata, and spec, including a single container with the latest image and port settings.

Learn common kubectl pod operations, from creating pods with YAML configurations to deploying updates, viewing details with describe, inspecting logs, and monitoring CPU and memory usage.

Explore Kubernetes pods through a practical demo aligned with the CKAD curriculum, helping learners understand pod concepts and how they fit into Kubernetes development.

Learn how replica set ensures high availability and load balancing by maintaining desired pod replicas, using labels and selectors to manage pods, and how deployments automate replica set creation.

Discover how the replica set and application controllers use a replication loop to continuously compare running parts against the desired count, creating or removing parts to match the template.

Explore everyday replica set operations starting from yaml-based creation to declarative updates, including get, describe, scale, set image, rollout, and delete, with both imperative and declarative approaches.

learn how to write a replica set YAML by comparing it with a replication controller, understanding apiVersion, kind, and selector options like matchLabels and matchExpressions.

Demonstrates a Kubernetes ReplicaSet in action, guiding CKAD learners through configuring and understanding ReplicaSet behavior for scalable, reliable pod replication.

Partition your cluster into virtual namespaces to segment environments and applications; use system and default namespaces, create private dev and prod namespaces, and enable network isolation.

Explore Kubernetes namespaces with a YAML walkthrough, creating a namespace in four lines and using a single command to manage and display resources in that namespace.

Master essential Kubernetes namespace operations, including creating from yaml, listing, describing, setting a default namespace, and deleting; and apply multi-resource yaml files with kubectl.

Explore namespaces in Kubernetes through a practical demo that shows how namespaces organize resources for applications.

Explore multi-container pods in Kubernetes, learn when to use them, and study three design patterns: sidecar, adapter, and ambassador, to implement robust container interactions.

explore how a multi-container pod runs together when a main container needs a supporting container, and scales together, using a two-container yaml example with a web server and safeguard container.

Learn why single container ports are preferred in Kubernetes pods, highlighting resource utilization across the cluster, easier scaling and load balancing, and simpler configuration compared to multi-container pods.

Explore sidecar and adapter design patterns for multi-container pods, along with the helper container concept. These patterns keep one-container-per-pod guidance, enable shared storage and localhost communication, and ensure pod-level scaling.

Learn how the sidecar multi-client pattern extends a main container with a companion synchronizer that keeps local files in sync with a remote source, sharing a volume.

Demonstrate the sidecar pattern in a Kubernetes application, highlighting how to integrate companion containers within a pod for enhanced functionality in the CKAD context.

Explore how the adapter pattern uses a helper container called an applicant to convert application logs into a standard monitoring format, with sidecar and ambassador roles.

Learn the ambassador DNA pattern, which hides complexity and provides a unified interface for accessing services outside the port via an ambassador container that routes requests to the right target.

Explore pod design by configuring labels, selectors, and annotations, deploying and updating applications with rollbacks, and scaling and scheduling jobs in Kubernetes.

Master how labels and selectors organize Kubernetes resources like pods, deployments, replica sets, and services, enabling efficient scheduling, scaling, and cross-component communication.

Learn to assign key-value labels to ports and tasks in YAML, use labels to filter and manage pods, and apply or remove labels declaratively with best-practice guidance.

Demonstrate how to use labels in Kubernetes to organize and select resources, highlighting practical labeling techniques for CKAD practice.

Learn how label selectors filter Kubernetes objects by labels, using equality, inequality, in, not in, and match expressions. Discover node selectors for scheduling on healthy nodes.

Demonstrates selector usage in kubernetes, showing how to apply selectors to target resources in CKAD scenarios.

Explore annotations in Kubernetes and compare them with labels. Learn how metadata in pods and deployments uses key-value pairs for external tools, not for object selection.

Discover how deployment manages replica sets and pods, enabling rollouts, rollbacks, scaling, and self-healing, and explore four strategies: recreate, rolling update, Canada deployment, and bluegreen upgrade.

learn about deployment strategies for upgrading applications with zero downtime deployment, including recreate, rolling update, canary, and blue-green deployments, with pros, cons, and when to use each.

Explore how the deployment yaml defines replica counts, pod management, and deployment strategies like rolling up and recreate, including max unavailable and max surge options for upgrades.

Create deployments via imperative commands or YAML, monitor replica sets and pods, inspect and describe deployments, update replica counts or images, then delete deployments with their replica sets.

Explore a hands-on deployment demo for Kubernetes within the Ultimate CKAD course, illustrating practical deployment workflows and essential concepts for application developers.

Perform a rolling update with zero downtime in Kubernetes by upgrading from v1 to v2, while traffic stays served, and rollback to a previous stable revision when needed.

Master rolling updates and rollbacks in Kubernetes by upgrading image 1.0.18 to 1.0.19 and restoring versions. Utilize declarative YAML with kubectl apply and imperative set image, and verify rollout history.

Master rolling updates and rollbacks in Kubernetes through a hands-on demo for CKAD preparation, with practical guidance on updating deployments and reverting changes.

Learn how to scale deployments by adjusting replica counts to manage traffic, with deployment controllers maintaining exactly the desired number of application instances in Kubernetes.

Scale Kubernetes deployments up and down using declarative YAML stored in a Git repository, or rapidly test with the imperative kubectl scale, while noting declarative changes are preferred for production.

Demonstrate scaling application instances in Kubernetes with a practical demo, guiding CKAD developers through deploying and managing containerized workloads.

Learn how Kubernetes jobs run batch tasks to completion, using a job resource to create pods, control parallelism, view logs, and clean up after success.

Watch a hands-on demo of Kubernetes jobs, illustrating how to create, run, and manage batch tasks within the CKAD framework.

Configure Kubernetes cronjobs to run recurring tasks by defining a cron schedule in a cronjob yaml, including starting deadlines and job templates for automated, time-based execution.

Demonstrates how to configure and use CronJobs in Kubernetes with a practical demo, reinforcing CKAD concepts for reliable task scheduling.

Explore configuring Kubernetes applications with config maps for environment variables and configuration files, manage resources with CPU and memory limits, configure security context, and differentiate service accounts for app access.

Explore the purpose of config maps, decoupling configuration from container images, and learn to store non-sensitive data as key-value pairs or files for use as environment variables, args, or volumes.

Learn how to create config maps from the command line and YAML files, using imperative and declarative methods, with key-value data, file-based values, and injecting into pods.

Inject config maps into pods using environment variables, startup command arguments, or files via a config map volume. Volumes support dynamic updates; env vars may not reflect changes.

Learn to create config maps via imperative command line and declarative config, inspect with get and describe, update with apply or edit, and delete, with output in yaml or json.

Explore configmaps through a hands-on demo that demonstrates how to store and inject configuration data in Kubernetes applications.

Learn the purpose of secrets in Kubernetes, contrast with config maps for nonsensitive data, and how to inject sensitive data as environment variables or files inside containers.

Create Kubernetes secrets with imperative and declarative YAML methods, using base64 encoding and data sections; understand secret types like generic and Docker registry, and view results with kubectl.

Learn two methods to inject secrets into a pod: using environment variables and mounting secret files via a volume, with username and password keys encoded in base64.

Explore essential secret object operations with kubectl, including imperative and declarative creation, viewing plaintext data, describe for troubleshooting, and edit or delete secrets.

Demonstrates how to manage secrets in Kubernetes as part of the CKAD curriculum, showing a practical demo for secure integration with applications.

Examine how ConfigMaps handle non-sensitive data and why Secrets store sensitive data. Note that ConfigMaps render plain text while Secrets encode with base64 and have size limits.

Discover how Kubernetes uses per-container resource requests and limits for CPU and memory to optimize utilization and guarantee resources, with YAML representations.

Define resource requests and limits in pod YAML to guarantee minimum CPU and memory for containers. Learn how node scheduling and limits prevent overuse and control pod resources.

Demonstrate resource limits in Kubernetes with a practical demo, guiding certified Kubernetes application developers in setting and validating resource constraints.

Learn how security context defines security-related configurations for the port and its containers, including user identifiers, read-only root filesystem, and capabilities, and how container-level settings take precedence over port-level settings.

Apply a pod-level security context to set the default user to 1000, primary group to 3000, and fsGroup to 2000 for all containers in the pod.

Configure security context at the container level to set operating system parameters for ports and containers, and learn how container-level run as user settings override port-level ones.

Learn how Linux capabilities in security context control container privileges by dropping default capabilities and adding only the necessary system capabilities to perform privileged calls safely.

Configure security context by setting run as user and run as group, enabling fs group, and enabling read-only filesystem, while dropping all capabilities and disabling privilege escalation.

Demonstrates security context usage in Kubernetes through a practical demo, aligned with CKAD objectives for learners.

Learn how service accounts differ from user accounts, and how to create namespace-scoped service accounts for pods via kubectl or YAML, including tokens and secrets for API access.

Explore service accounts through a hands-on demo for Kubernetes application development, illustrating how to configure and use service accounts in CKAD workflows.

Explore how application components communicate and expose them to the internet using Kubernetes services. Master basic network terminology, Kubernetes networking, ports, network interface, service types, and network policy.

Explore basic network terminology—NICs, switches, routers, firewalls, protocols, and packets—and learn how these components enable device communication, secure data, and connect networks across the internet.

Discover Kubernetes cluster networking basics, including pod-to-pod, port-to-port, and port-to-service communication, and learn how the pod network model uses sandbox containers and CNIs like Calico or Flannel.

Open inbound tcp ports for the Kubernetes control plane and worker nodes, including 6443, 2379, 10251, and 10252, with firewall rules in Google Cloud to manage ingress and egress.

Explore services, why they exist, how labels select pods, and how they provide a stable IP, DNS name, and port with front-end and back-end pods and load balancing.

Compare stripey service (ClusterIP) for internal cluster access, norport (NodePort) for external web exposure with caution, and load balancer service for scalable external access with higher costs.

showcase a practical demo of the NodePort service in Kubernetes for the ultimate CKAD course, illustrating how to use node port configurations in real-world scenarios.

Discover how kube-proxy on every node routes service traffic to the ports backing a service, with a stable ip and iptables-based load balancing.

Network policies control how pods communicate, enforce deny-by-default behavior, and require a compatible network plugin, as Flannel may not support policies.

Explore network policy use cases to deny by default, selectively allow internet access using labels, and restrict port communication within the same namespace and across namespaces for secure Kubernetes apps.

Demonstrates how to use a deny network policy in Kubernetes to restrict pod-to-pod traffic, reinforcing secure application networking for the CKAD framework.

Explore how to implement Kubernetes network policy to limit traffic and isolate pods, demonstrated through a practical limit scenario for the CKAD certification.

Demonstrate applying a network policy that allows access in a Kubernetes environment, presented as a practical demo.

Explore state persistence by examining storage volumes, including non-persistent versus persistent storage, their purpose and lifecycle; learn access modes, policies, and manual provisioning of a volume to configure an app.

Explore storage volumes, why they are needed, and how stateful data uses persistent storage, while stateless apps rely on temporary storage or caching.

Explore Kubernetes volume types, comparing emptyDir and hostPath, and review persistent disks from cloud providers and network storage options like NFS and iSCSI, plus config maps and secrets.

Learn how to use hostPath volume, a node directory, to store temporary files inside a container. Configure volume details and mounting, using a test hostPath volume, and avoid database storage.

Perform a HostPath volume demo to illustrate mounting host directories in Kubernetes for CKAD practice.

Learn what persistent storage is and why it stores application data or databases so it remains available when a pod is rescheduled, and explore cloud disk and network storage options.

Learn to create and use a Google Cloud persistent disk for long-term data. Mount a MongoDB data volume in a container and deploy in a cluster.

Demonstrate persistent storage with GCE persistent disks in Kubernetes, showing provisioning and usage in a hands-on demo.

Explore persistent volumes and claims in Kubernetes: admins create PV, developers request via PVC, and Kubernetes binds storage, enabling app deployment without infrastructure details.

Learn how persistent volumes (PV) and persistent volume claims (PVC) enable durable storage in Kubernetes, contrast with ephemeral volumes, and deploy a database with Google Cloud persistent disks.

Master how a persistent volume claim binds a persistent volume to a pod, abstracting storage details and preventing reclaims, with static or dynamic provisioning via storage classes.

Learn how volume access modes—ReadWriteOnce, ReadOnlyMany, and ReadWriteMany—are supported by different storage providers, how to set one in PV YAML, and why only one mode applies per PV.

Learn the two volume modes in Kubernetes: filesystem and block. Default is filesystem; block mode presents a raw device without a filesystem, for use with persistent volumes and claims.

Learn how reclaim policies manage persistent volumes in Kubernetes, covering static and dynamic provisioning, PVC and PV lifecycles, and options like delete, retain, and recycle.

Manually create a disk on Google Cloud, configure a PV and PVC, and mount the PV into a pod. Learn static provisioning and the option of dynamic provisioning.

Configure a pod to use static persistent storage with PV and PVC, demonstrated in a practical CKAD-focused demo.

Explore observability to monitor status, review logs, and troubleshoot applications, nodes, and cluster components with liveness and readiness probes guiding traffic to healthy instances.

Explore monitoring for a kubernetes cluster to ensure reliability, gain insight into current and historical monitoring data, and enable alerts that optimize resources and control costs.

Explore monitoring layers from hardware and the operating system to applications, containers, and orchestration capabilities, and learn to monitor processes, services, and components across these layers.

Monitor node resources, including cpu, ram, disk, storage capacity, and network performance, to identify bottlenecks and ensure cluster health with node exporter metrics to Prometheus.

Explore built-in Kubernetes monitoring tools, from metrics server to central matrix and dashboards, and compare open-source options like Prometheus and Gravagna with commercial tools such as Duty Dog and directress.

Explore the monitoring pipeline from data sources to visualizations, detailing data sources on nodes, aggregation with Prometheus, storage via InfluxDB, and dashboards in Grafana.

Learn the monitoring architecture of a three-node Kubernetes cluster, collecting container, pod, and node metrics—CPU, memory, and disk—via an open source agent and a centralized metrics server.

Install metrics server to monitor cpu and memory usage of pods and nodes in your cluster, using kubectl top.

Install the metrics server to enable Kubernetes monitoring in a practical demo for CKAD learners.

Monitor cluster components by checking node health and resource usage for master and worker nodes, and inspect kube-system pods and core components like kube-scheduler and kube-controller-manager.

Monitor applications deployed on the cluster using custom metrics and health checks, including readiness and liveness probes, to ensure uptime and automatic recovery.

Demonstrate monitoring Kubernetes applications through a hands-on demo, highlighting essential practices for observing performance and reliability.

Logging captures system and application events to aid debugging and monitoring, including timestamps, user IPs, and resources accessed. Classify messages as informational, warning, or error by their first letter.

Explore the four stages of a Kubernetes logging pipeline: identify data sources—application, component, and system logs from all nodes—then use a fluid aggregator, ElasticSearch storage, and Kibwana visualization.

Explore the end-to-end logging architecture in Kubernetes: identify data sources from pods, aggregate logs with fluentd, store in Elasticsearch, and visualize with Kibana on a dashboard.

Learn how to view and troubleshoot component logs in Kubernetes using kubectl logs and journalctl, with alternatives like docker logs for container and service unit deployments.

Learn to use kubectl logs to inspect containerized applications in pods and debug issues, and explore centralizing logs with third-party solutions for monitoring.

Demonstrate practical logging techniques within a Kubernetes application development context, guiding learners through a hands-on demo of how to capture, monitor, and troubleshoot containerized workloads.

Learn how Kubernetes liveness health checks keep containers alive by restarting pods when probes fail, covering http get, exec, and tcp socket probe types.

Explore liveness probes in Kubernetes, configuring http get, command, and tcp socket checks via yaml to verify container health. Learn how initial delay and period settings govern probe timing.

Explore configuring a liveness probe in a Kubernetes environment through a live demo for CKAD learners.

Learn how readiness health checks determine when an application is ready to accept traffic and how readiness probes, including three types, remove non-ready ports from service routes.

Configure readiness and liveness probes in yaml for a container on port 880 using a tcp socket, with readiness after five seconds, liveness after fifteen, and checks every ten seconds.

Demonstrates Kubernetes readiness probes with a hands-on demo, helping learners master container startup checks and deployment health in the Ultimate CKAD course.

Learn practical troubleshooting for pods, replica sets, and services on the cluster, diagnosing port states, resource constraints, image issues, and deployment errors to keep applications running.

Verify all cluster nodes are ready and visible, using node listing and description for details. Review component logs and confirm core services and ports in the system namespace are running.

Identify the health status of worker nodes, diagnose unknown states, inspect memory and disk, and verify kubelet status with kubectl, using top and df as needed, restarting kubelet if required.

Demonstrate troubleshooting a kubernetes cluster through a hands-on demo, guiding learners through diagnosing and resolving issues aligned with CKAD concepts.

Register for the CKAD exam by visiting the Linux Foundation page, logging in, and completing payment; watch for coupon discounts and note you have one year to complete or reschedule.

Discover 25 actionable tips to score 100 percent in the CKAD exam, from target setting and registration to practical cluster practice, exam strategies, and time-management.

Master the easy first strategy for CKAD by solving easy and medium questions first, then complex ones, using 40 minutes for easy, 60 for complex, and 20 for final review.

Learn to manage exam time effectively by using bookmarks to access official CKAD resources quickly, organize pages into curriculum-aligned folders, and jump to YAML configurations and examples in two seconds.

Track all CKAD topics with the exam tracker, a one-stop tool aligned to the official curriculum, to ensure you cover about 40 plus topics and are exam ready.

Follow a 10-step pre-start CKAD checklist—review notes, set up external monitor and separate browsers, ensure a clean workspace and tech—then log in early and stay calm during the two-hour exam.