Kubernetes CKAD - Learn The Practical Way + Practice Exam

Understand pods as the core unit that wraps containers and runs images to deliver running applications within a kubernetes cluster, including the control plane and nodes.

Demonstrate creating a pod with kubectl run using an nginx image, check status with kubectl get pods, and access the pod via curl.

Learn to manage pods with kubectl, including creating imperatively, backing up configurations to yaml, reapplying changes with apply, and using describe to debug events like image pull failures.

Learn how to define and use labels in Kubernetes metadata to categorize pods by environment, such as prod, test, and dev, and how to filter pods using selectors.

Explore how replica sets in Kubernetes maintain the desired number of pod replicas for availability. Ensure failed pods are replaced with the same configuration to keep the replica count steady.

Learn how a replica set in Kubernetes uses templates and labels to ensure a desired number of pod replicas, with selectors matching front end pods and automatic pod replacement.

Create a deployment in an imperative way with kubectl create deployment <name> --image <image>, defaults to one replica, then scale with kubectl scale deployment <name> --replicas <n> and view yaml.

Understand how namespaces create a logical boundary to isolate dev, qa, and prod within one Kubernetes cluster, enabling resource quotas and role-based access control.

Learn how to manage environment variables with Kubernetes config maps, using imperative and declarative creation, injecting values via env from config map, and updating pods to pick changes.

Use secrets to securely pass passwords as environment variables, keeping values encrypted and not visible. Create a secret with kubectl and reference it via secret key ref in the pod.

Set resource requests and limits for each container in Kubernetes to guarantee minimum cpu and memory while capping usage, protecting production workloads from dev memory spikes.

Explore how a pod can host multiple containers, including sidecars for proxies and log aggregation, and preview a two-container pod with nginx and tomcat.

Explains temporary pods in Kubernetes, demonstrating how to create a temporary nginx pod with --rm and -it to test connectivity to another pod, a handy debugging and exam technique.

Master Kubernetes logging with kubectl logs: view pod and container logs, inspect init containers, use -c for a specific container, --all-containers, and -f to tail.

Learn how readiness probes use an HTTP GET check to verify a pod is ready to receive traffic, returning HTTP 200 after initialization and periodic checks.

Learn how liveness probes monitor pod health to automatically restart unhealthy pods, maintain the desired number of ready instances, and keep traffic healthy in Kubernetes.

Explore volumes as storage for pods, including temporary and persistent options. Learn to declare and mount volumes in a pod using pod, node, and external volume types.

Explore hostpath volumes by attaching a node directory to a pod, mounting it at /cash, and understand persistence, ephemeral pods, and limitations with replicas across nodes.

Explore empty directory volumes, an ephemeral pod-scoped storage that provides a temporary, non-persistent disk mounted at a container path, vanishing with the pod lifecycle.

Explore external volumes in Kubernetes, including block storage, file storage, and NFS mounts, and learn how to declare, mount, and use them across containers, with the topic of persistent volume.

Explore pv and pvc binding, storage class requirements, and why deleting a pvc frees a pv only after the claim ends, illustrated by 2 gb, 3 gb, and 4 gb examples.

Explore storage classes, dynamic provisioning, and runtime expansion for block and file storage in Kubernetes, using a Google Cloud persistent disk example to illustrate provisioning, binding, and expansion.

Learn how Kubernetes services enable reliable access to pods, provide load balancing and service discovery, and manage changing pod IP addresses across deployments with replicas.

Create and expose a nginx pod with a cluster IP service, mapping port 80 to 80. Observe the service IP and how pod replacements update endpoints.

Diagnose cluster IP service issues by inspecting endpoints, using kubectl describe and edit to fix target ports and selectors, and verify connectivity between port 80 and 8080.

Learn how NodePort service exposes cluster applications to outside clients by creating a NodePort on every node, using the NodePort IP and port to route to the target pods.

Deploy an app and expose it with a nodeport service, mapping 8080 to 80. Learn access via cluster IP, node IP, and why load balancer services suit internet exposure.

Discover how a load balancer type service creates an external cloud load balancer, exposing a private Kubernetes cluster via a stable IP or DNS name to the external world.

Explore using a load balancer type service in a Kubernetes cluster via a cloud provider, deploying nginx and exposing the deployment for external IP load balanced traffic.

Discover ingress as a scalable alternative to multiple load balancers, providing a single entry point that routes traffic to back-end services using host and path rules.

Explore how Kubernetes schedules pods to nodes using resource requests, node affinity and selectors, and tolerations to control placement across production, test, and dev environments.

Learn how taints and tolerations control pod scheduling by locking nodes 1 and 2 to database pods, while non-db pods go to nodes 3 and 4, using tolerations as keys.

Learn how to taint and tolerate nodes using kubectl taint and pod tolerations, including no schedule and no execute effects, with imperative demos on node zero one.

Learn how taints and tolerations affect pod scheduling, diagnose pending pods by inspecting node taints, and apply a toleration to let the pod schedule on eligible nodes.

Learn how to schedule a pod to specific nodes using taints and tolerations, and compare node name, node selector, and node affinity.

Master node affinity in Kubernetes to express scheduling constraints with match expressions and operators like in and not in, selecting master or worker nodes.

Learn how to manage deployment rollouts and rollbacks in Kubernetes, including canary and blue-green strategies. Edit live deployments and use kubectl rollout commands for status, history, and undo.

Explore deployment strategies in Kubernetes, including rolling updates and recreates, and learn how to configure replicas and output deployment YAML with kubectl.

learn how the recreate deployment strategy deletes all old replicas before creating new ones, ensuring no coexistence of versions, demonstrated with version 1.0 to 2.0 while observing rollout status.

Learn canary deployment, a gradual rollout in Kubernetes that tests a new version with a subset of users before full release, alongside blue-green strategies.

Learn to implement canary deployment in Kubernetes by running parallel v1 and v2 deployments, exposing them via a cluster IP service, and gradually scaling v2 for rollout.

Demonstrates blue-green deployment in Kubernetes by creating v1 and v2 deployments, testing internally, swapping the service to v2, and safely scaling down v1.

Explore security in Kubernetes from a developer’s view, covering pods, namespaces, and access control with service accounts, security context, roles, and network policy for protecting apps in dev and prod.

Discover what a service account is, its namespace scope, and how to create one and attach it to a pod so the pod inherits the account’s permissions.

Define a pod-level security context to run containers under a specific user and group, control file system permissions, and optionally make the root filesystem read-only.

Explore how Kubernetes RBAC uses roles and role bindings to grant namespace-scoped permissions on pods and deployments, and bind these roles to users or service accounts.

Demonstrates creating a service account, attaching it to a role via a role binding, and verifying permissions with kubectl. Shows applying multiple rules across pods, services, and deployments.

Identify how to restrict access using role and role binding to specific resources, such as pods, with resource names and kubectl apply, showing test one and test two.

Master cluster role and cluster role binding to manage cluster-scoped resources, using YAML similarly to roles, and apply them to non-namespaced elements like secrets and persistent volumes.

Show how to implement a simple Kubernetes network policy with YAML files, restricting frontend to access the db on port 80 and validating access before and after application.