Kubernetes Certified (KCNA) + Hands On Labs + Quizzes

See how cloud native architecture replaces brittle monoliths with loosely coupled microservices, enabling observable, resilient systems guided by robust automation and scalable data stores.

Design resilient cloud native systems with Kubernetes self-healing replicas that recover from failures. Embrace automation, CI/CD, secure-by-default practices, autoscaling, serverless patterns, and service discovery for speed and cost efficiency.

Explore autoscaling types—reactive, scheduled, and predictive—and how Kubernetes tools like cluster autoscaler, HPA, VPA, and KEDA enable horizontal, vertical, and scale-to-zero strategies using CPU and memory metrics.

Explore how serverless uses provider-managed servers and on-demand resources to run code at any scale, via AWS Lambda as a FaaS, with event-driven execution and autoscaling to zero.

Explore how the cloud native CNCF governs projects from sandbox to graduation, crossing the chasm with TOC oversight, maturity signals, and open governance practices.

Explore cloud native personas such as DevOps, SRE, CloudOps, DevSecOps, cloud architects, and data engineers, and learn how these roles complement each other within cloud native culture.

Explore open standards that enable OCI image formats, runtimes, and distributions, with examples from Docker, runC, and Kubernetes CNI, CSI, CRI, and SMI for cloud-native flexibility.

Trace the evolution of container technology from mainframe virtualization and chroot to Linux namespaces and cgroups, and learn how Docker and Kubernetes enable isolated, resource-controlled containers.

Install and configure Docker Desktop on Mac, Windows, and Linux, set up a Kubernetes node within Docker Desktop, and run containers to explore Docker and Kubernetes integration.

Explore container images, their layers and tags, including latest, and how OCI compliance, registries, digests, and image IDs verify and manage multi-arch containers.

Learn to run containers with Docker, including a version check, the funbox image, interactive sessions (-i -t), and automatic cleanup (--rm).

Explore docker networking and volumes using the nginx image, publishing ports, inspecting containers, and mounting host directories to serve dynamic content.

Build a lightweight container image from Alpine using a Dockerfile, apply labels, fetch cmatrix, and compile a static binary with autoreconf, autoconf, automake, and ncurses.

Learn to build and optimize a cmatrix docker image by iterating dockerfile changes, using workdir, multi-stage builds, and entrypoint versus cmd to create a lightweight, reproducible container.

Learn to build cross-platform container images with Docker buildx, push multi-arch images to Docker Hub, and clean up artifacts with prune, enabling amd64 and arm64 usage.

Explore container orchestration as the key to running containers at scale, covering provisioning, deployment, scaling, networking, storage, security, and autoscaling with Kubernetes and CRDs.

Examine the Kubernetes architecture by exploring the control plane and nodes, including etcd, kube-apiserver, kube-scheduler, kubelet, and kube-proxy, to understand pod creation and service networking.

Set up the Kubernetes lab environment with Docker Desktop, update to a modern version, install the DiveInto Labs extension, load labs by identifier, and customize the workspace.

Discover setting up a Kubernetes lab with Google Cloud Shell, using a free Google account, an ephemeral environment, and previewing the lab on port 8080.

Set up the Kubernetes lab with Docker Compose on a modern Linux kernel with cgroups v2, pull the lab, start the environment, and enter the lab id for access.

Explore how Kubernetes pods are the smallest deployable units that host containers with shared networking and unique IP addresses, then deploy nginx and inspect pod communication with kubectl tools.

Learn to build Kubernetes pods from yaml, including multi-container pods, explore restartPolicy options, use kubectl with dry-run and -o yaml to generate and save declarations, and apply declarative configurations.

Create a single pod with two containers (webserver and sidecar) and manage yaml layouts. Observe the shared IP, monitor logs, simulate crashes, and compare declarative versus imperative pod creation.

Troubleshoot Kubernetes pods using describe, logs, and exec to diagnose Pending, ImagePullBackOff, and CrashLoopBackOff, and use events for debugging.

Explore how Kubernetes namespaces isolate resources and support multi-tenant management with quotas, limitranges, and RBAC. Practice with kubectl to list, create, and switch namespaces and set context.

Master Kubernetes deployments and ReplicaSets for declarative app updates, scaling, and safe rollbacks. Learn to monitor rollouts, annotate changes, and manage image updates with kubectl.

Explore how Kubernetes DaemonSets run one pod per node, enabling node-level services for log collection, monitoring, and CNI networking, with hands-on deployment conversion.

Master kubectl set image and kubectl patch to update container images on pods and deployments, and perform targeted partial updates to replicas, labels, and environment variables.

Explore Kubernetes services, including ClusterIP, NodePort, LoadBalancer, ExternalName, and headless service, with hands-on examples of exposing deployments, endpoints, and DNS-based service discovery.

See how Kubernetes jobs run batch tasks, track progress, and retry on failure. Use cron jobs to schedule recurring tasks like daily reports and system maintenance.

Explore how to create and use Kubernetes ConfigMaps to store configuration data and environment variables in pods via envFrom and configMapRef. Learn about ConfigMap immutability and that updates require recreation.

Learn how Kubernetes secrets store sensitive information like passwords and keys, distinguish secrets from configmaps, and view base64 encoded data using kubectl and secretRef in pods.

Learn how Kubernetes labels and label selectors identify, group, and manage resources, enabling service discovery, load balancing, and network policy implementation across pods, services, and deployments.

Discover how Kubernetes annotations differ from labels, store descriptive metadata, and drive controller behaviors to trigger rollouts in real-world clusters using ingress, service meshes, and observability tools.

Explore Kubernetes startup, liveness, and readiness probes, learn how startup delays affect readiness and liveness, and see how probes use HTTP, TCP, or gRPC to manage pod health and traffic.

Explore the Kubernetes API, a RESTful interface for managing pods, services, volumes, and other resources, with authentication, authorization, admission control, and custom resource definitions.

Explore the Kubernetes API from a user perspective using kubectl to issue requests and view nodes. Use OpenAPI and Postman to explore endpoints, create pods, and delete pods via API.

Explore Kubernetes RBAC from the ground up, showing how policies grant actions to users, groups, and service accounts with defined roles on resources like pods and services, guided by kubeconfig.

Master Kubernetes RBAC at cluster level by binding a cluster-admin to groups like system:masters, and verify permissions with kubectl auth-can-i.

Master Kubernetes RBAC by creating users and groups, issuing certificates, and building kubeconfig files, then enforce access with cluster and namespace roles and bindings across real-world examples.

Explore how the kube-scheduler uses filtering, scoring, and binding to place pods on nodes, considering resources, constraints, and nodeName.

Master taints and tolerations to control pod placement on nodes, using key=value:effect formats and tolerations like exists or equals across kubeadm, k3s, and deployments.

Explore Kubernetes affinity to control pod scheduling with node and pod affinity/anti-affinity, using required and preferred rules, topology keys, and practical labeling examples.

Master inter pod affinity and anti affinity to schedule pods by topology, using topologyKey like kubernetes.io/hostname or topology.kubernetes.io/zone, and matching on labels such as role=backend.

Explore ephemeral and persistent Kubernetes storage, including emptyDir backed by memory for fast caches, and demonstrate manual and dynamic PV/PVC provisioning with k3s local path and reclaim policies.

StatefulSets manage stateful applications by giving each pod a sticky identity, with partitioned updates. They provide stable network identifiers and per-pod PVCs with storage class provisioning.

Apply Kubernetes network policies to isolate pods and control ingress from allowed namespaces and IP blocks, using labels to restrict access to services like nginx, enhancing multi-tenancy security.

Explore how Kubernetes ingress centralizes http and https routing via ingress rules, enabled by an ingress controller such as nginx-ingress, with ssl termination and simplified management.

Configure and test kubernetes ingress using default ingressclass, annotations, and host-based routing to direct traffic to nginx-frontend, nginx-api, and nginx-admin across /, /api, and /admin.

Configure a Kubernetes ingress with tls using a self-signed certificate and tls secret. Test http to https redirects with curl, and explore prefix vs exact path matching.

Learn how the Gateway API replaces legacy ingress with GatewayClass, Gateway, and HTTPRoute resources to enable role-based, multi-tenant routing with TLS, listeners, and policy guards.

Explore how Kubernetes Pod Disruption Budgets maintain application availability during voluntary disruptions by enforcing a minimum number of available pods, contrasting with replicas.

Explore the four-layer model of Kubernetes security, including authN/authZ, admission control, workload runtime settings, and the network and data plane, covering RBAC, pod security, network policies, and runtimes like gVisor.

Learn how Kubernetes security contexts control pod and container privileges, using runAsUser and runAsGroup to run as non-root and prevent root escalation in a practical hands-on demo.

Discover how Kubernetes Pod Security Admission enforces pod security through namespace labels and Pod Security Standards, with Enforce, Warn, and Audit modes and Privileged, Baseline, and Restricted profiles.

Apply Kubernetes resource quotas to a namespace to cap CPU, memory, and pod counts, ensuring fair resource sharing in multi-tenant clusters and enforcing per-namespace requests and limits.

Learn to install Helm, create and package a Helm chart, and deploy a flappy-dock game app on Kubernetes, using values.yaml configurations and kubectl commands.

Kustomize, built into kubectl, manages Kubernetes configurations with a base and overlays via kustomization.yaml, enabling name prefixes, patches, and selectors across dev and prod environments.

Master how service meshes secure, observe, and manage microservice traffic with data plane and control plane architectures, using sidecar or host proxies and SMI standards.

Explore cloud native observability by examining telemetry, logs, metrics, and traces, and how alerts enable proactive, high-quality monitoring of distributed systems.

Accelerate Kubernetes observability with Prometheus and Grafana, leveraging PromQL for time-series data, alerting, and dashboards, and integrating data sources for real-time monitoring of SLAs, SLOs, and SLIs.

Set up observability with helm using the kube-prometheus-stack to deploy Prometheus, Grafana, and related components, then explore metrics via the Prometheus user interface and Grafana.

explore hands-on Grafana and Prometheus integration by importing community dashboards and inspecting promql queries for global cpu usage in a Kubernetes cluster, with cleanup steps.

Explore cost management for cloud native solutions by using on-demand, reserved, and spot resources, right-sizing, autoscaling, and hybrid or private cloud options; leverage anomaly detection and kubecost.

Explore cloud native application delivery and GitOps using Argo CD to manage Kubernetes deployments with declarative infrastructure, automatic sync, and real-time reconciliation.