3 Kubernetes Certifications - CKA, CKAD & CKS Crash Course

Learn how to install minikube for Kubernetes development, including hardware needs, platform options, and commands to install, verify context, and use the dashboard and port-forward for exam preparation.

Learn to create Kubernetes secrets and consume them in a deployment, injecting secret values as environment variables and mounting them as files in a volume.

Create a generic secret and consume it in a pod by configuring an environment variable from a secret key reference using the secret name and key one with engine x.

Learn to create and consume Kubernetes config maps from literals, environment files, and properties files, then inject them into deployments via env vars and volume mounts.

Explore a scenario-based exam task on creating and consuming a Kubernetes config map in a pod via a volume mount, using the engine x image, and verifying the mounted value.

Learn how to enable and observe a readiness probe in Kubernetes with a practical Nginx example, showing startup delays, readiness checks on an endpoint, and a pod moving to ready.

Learn how liveness probes provide ongoing health checks to restart unhealthy containers in Kubernetes. Compare this with readiness probes that control traffic routing.

practice scenario based debugging of a failing liveness probe by locating broken pods, logging errors, and fixing file access and port configuration to restore app reachability.

Explore Kubernetes probes with startup, liveness, and readiness checks on an engine X deployment, including namespace setup, YAML configuration, and step-by-step status verification.

Explore Kubernetes cron jobs via a clone job demo in a cron-job-demo namespace, using a yaml with active deadline seconds, backoff limit, completions, parallelism, and a one-minute schedule.

Explores a scenario-based Kubernetes cron job task, creating a yaml manifest to run a busybox date command every minute and complete once. Verify the job runs successfully at least once.

Demonstrates Kubernetes role based access control by creating a namespace, a reader role with get, list, and watch for deployments, binding a user, and validating permitted and forbidden actions.

Explore Kubernetes deployments by creating a namespace and a demo deployment with two containers, exposing services, scaling replicas, updating resources and images, enabling autoscaling, and cleaning up.

fix a deprecated deployment by updating the manifest's apiVersion to apps, add the cobra namespace, and ensure the selector matches the labels, then deploy the updated YAML to the cluster.

Update a Kubernetes deployment to set a security context with user id 30000 and forbid privilege escalation, by editing the deployment manifest in the code namespace.

Master essential vim tips for the cka, ckad, and cks exam, including backups, search and replace, insert mode, indentation, multi-line selection, and yaml edits with save and quit.

learn to use kubectl get events to monitor deployments and pods across namespaces, apply field selectors like kind=deployment and name to filter events, and review results before cleanup.

Learn to search like a pro for the CKAD exam using kind:, YAML snippets, and targeted keywords to quickly access RBAC, secrets, service accounts, and liveness, readiness, startup probes.

Learn the logging sidecar pattern in Kubernetes, where a producer container shares logs with a sidecar that tails them for processing or forwarding to systems like Splunk.

Explore the ambassador pattern by wiring a proxy between a client pod and a backend service, using a config map to define frontend on port 9000 and backend on 10000.

Learn to perform Kubernetes rolling updates with max surge and max unavailable, monitor rollout status and history, rollback to previous revisions, and scale deployments.

Demonstrates scenario to provision hostPath storage class 'exam' with 1 Gi PV and 100 Mi PVC, create /tmp/data/index.html with account=finance on the worker, and mount it in a labeled pod.

Master the CKS exam with security-focused tips and strategies for 16 cluster contexts; learn allowed resources, context switching, and how to access master and worker nodes.

Explore trivy for image vulnerability scanning in a Kubernetes certifications exam. Set up on Linux, Mac, Windows, and Docker; learn commands and automate multi-image scans for high and critical findings.

Learn how to scan pod images for high and critical vulnerabilities, create a Pod Check namespace with sample pods, and clean up by deleting vulnerable pods.

Extract secrets from Kubernetes and save them to a file by demonstrating jsonpath, template, yq, and base64 decoding, with practical steps and cleanup.

Showcases how gVisor isolates an application from the host kernel and guides creating a runtime class, applying it to pods and deployments, and verifying isolation.

Learn how to apply the CIS benchmarks to harden a Kubernetes cluster using kube-bench, identify fail steps, and implement remediation for controls like RBAC, API server settings, and config changes.

Fix dockerfile and deployment.yaml by applying security best practices: pin image tags, run as non-root, remove hardcoded credentials, and enforce read-only root filesystem and strict security contexts.

Explore AppArmor, a kernel-level prevention module for Kubernetes, demonstrating temporary profiles, profile loading, and deployment annotations to deny container file writes on the worker node.

Enforce policy on Kubernetes with gatekeeper, a customizable admission webhook powered by open policy agent; define constraint templates and constraints for labels, replicas, and images from trusted registries using YAML.

Master port security policy in Kubernetes: define cluster-level rules for pods and ports, enforce them via cluster roles and bindings, and test privileged vs non-privileged pods.

Create a new service account, role, and role binding in the target namespace to list pods, namespaces, and config maps, then update the frontend pod to use the service account.

Narrow a service account's permissions by editing existing role to limit get on ports, then create and bind a new role to the same service account that updates stateful sets.

Configure the admission controller to integrate an image scanner service, switch the image policy to implicit deny, and point the endpoint to localhost:10000/scan, then test with a vulnerable image.

Explore a scenario-based network policy for the certified community security specialist exam. Block all ingress by default, then allow client-to-server traffic on port 80 within the namespace demo.

Create a default deny network policy in the backend namespace and a second policy that allows frontend namespace and administration labeled traffic to backend server ports.

Learn how to read Kubernetes secrets from etcd by querying secrets in the default and a named namespace, including creating a sample secret and retrieving username and password.

Create an ingress object, expose a deployment via http, and then secure it with tls by generating a certificate, creating a secret, and updating the ingress for https.

Master kubectl node commands to inspect, label, taint, drain, and manage Kubernetes nodes, including viewing node details, events, and resource usage for effective cluster maintenance.

Learn to manage Kubernetes namespaces with kubectl: list, create, describe, label, view yaml, set resource quotas and limit ranges, and switch contexts to target namespaces.

Master daemon set management with kubectl by creating, describing, editing, and applying daemon sets, updating images, watching rollouts, and selecting pods with label selectors, node selectors, and tolerations.

Master kubectl statefulset commands to manage stateful sets, including listing, describing, applying manifests, scaling, rolling updates, image changes, rollbacks, and clean deletion with cascade options.

Learn how to use kubectl to manage services: list, describe, output YAML/JSON, create cluster IP, NodePort, load balancer, headless, external name, and test connectivity across namespaces.

Explore kubectl configmap commands, including creating, viewing, editing, and deleting config maps across namespaces, with from-file, from-literal, labels, patch, and yaml and json outputs.

Explore kubectl secrets commands to manage, view, create, and modify secrets across namespaces. Learn to work with TLS, Docker registry secrets, file secrets, env files, labels, patching, and access checks.

Learn kubectl storage commands to manage storage classes, PVs, and PVCs, including provisioning, describing, patching and applying manifests across namespaces.

Learn to manage Kubernetes jobs and cron jobs with kubectl, including creating, describing, monitoring, and cleaning up jobs, cron jobs, and their YAML templates.

Discover kubectl rbac commands to manage roles, cluster roles, and bindings across namespaces, test permissions with can i, and bind roles to users and service accounts.

Learn to manage kubectl requests and limits, choosing safe millicore CPU and mib memory units, and understand quality of service classes, guaranteed, burstable, and best-effort, with deployments and multi-container pods.

Understand taints, tolerations, and node affinity for Kubernetes pod placement, including no schedule, prefer no schedule, and no execute, and see how these rules guide or restrict scheduling and affinity.