Use YAML to describe real configuration without getting lost in spacing, maps, lists, and strings. You will read and edit the kind of files Kubernetes uses every day.

Trace the path from physical servers to virtual machines, containers, Borg, Docker, and Kubernetes. The goal is to see why clusters, declarative APIs, and automated reconciliation became the standard way to run modern services.

Create a local cluster and use kubectl to ask what is running, where it is running, and what changed. You will get comfortable with contexts, namespaces, resources, and basic troubleshooting commands.

See the control plane, worker nodes, kubelet, container runtime, API server, scheduler, controllers, and etcd as one working system. This chapter shows what happens after you submit a manifest.

Run containers inside Pods, inspect their status, set commands and arguments, and use labels to find them. You will see why the Pod, not the container, is Kubernetes’ smallest deployable unit.

Use Deployments and ReplicaSets to keep the right number of Pods running, replace unhealthy Pods, and roll out new versions. You will practice scaling, pausing, rolling back, and reading rollout history.

Give Pods stable network access with Services and route outside traffic into the cluster with Ingress. You will connect an app, test DNS, and see how Kubernetes hides changing Pod IPs.

Store non-secret settings in ConfigMaps and sensitive values in Secrets, then mount them as files or environment variables. You will also cover safe update patterns and common mistakes that leak secrets.

Request CPU and memory, set limits, and read what happens when a container is throttled or killed. This chapter connects app behavior to scheduling, reliability, and cost.

Add readiness, liveness, and startup probes so Kubernetes knows when to route traffic, restart a container, or wait longer. You will design health checks that help instead of hiding real failures.

Use PersistentVolumes, PersistentVolumeClaims, and StorageClasses to give apps durable storage. You will see which storage choices fit databases, uploads, caches, and shared files.

Run stateful systems with StatefulSets, stable names, ordered rollout behavior, and attached storage. You will practice when Kubernetes is a good home for databases and when it adds risk.

Run one-time Jobs and scheduled CronJobs for tasks like migrations, reports, cleanup, and backups. You will handle retries, deadlines, concurrency, and failed runs.

Use node labels, taints, tolerations, affinity, and topology spread constraints to place workloads where they belong. This builds judgment for performance, availability, hardware needs, and isolation.

Read cluster DNS, Service types, kube-proxy behavior, network plugins, and NetworkPolicies. You will map how packets move between Pods, nodes, Services, and the outside world.

Use ServiceAccounts, RBAC Roles, RoleBindings, and least-privilege access for humans and workloads. You will practice granting exactly what is needed and checking permissions before changes go live.

Harden containers with security contexts, non-root users, read-only filesystems, capabilities, and Pod Security Standards. This chapter turns common security advice into working manifests.

Install, upgrade, and remove applications with Helm charts while reading the templates they produce. You will also use Kustomize for environment-specific overlays without copying whole manifests.

Follow a real service from code to image, registry, manifests, rollout, health checks, traffic, monitoring, rollback, and cleanup. This chapter ties together the daily workflow behind a production Kubernetes release.

Connect Kubernetes to CI systems so tests, image builds, scans, deployments, and rollbacks happen repeatably. You will compare push-based pipelines with cluster-pulled deployment flows.

Use Git as the source of truth for cluster state with tools such as Argo CD or Flux. You will handle drift, pull requests, promotion between environments, and emergency fixes.

Extend Kubernetes with CustomResourceDefinitions and controllers that reconcile desired state. You will see how Operators automate databases, queues, certificates, backups, and other complex systems.

Use admission controllers, validating policies, mutating webhooks, and policy engines to block unsafe changes before they reach the cluster. You will turn rules about images, privileges, labels, and resources into enforceable guardrails.

Collect logs, metrics, and events so failures can be seen quickly. You will work with common patterns such as Prometheus metrics, structured logs, dashboards, and alert rules.

Trace requests across services, connect traces to logs and metrics, and use OpenTelemetry-style instrumentation. This helps diagnose slow calls, retries, dependency failures, and user-facing outages.

Use rolling updates, blue-green releases, canary traffic, Pod disruption budgets, and graceful shutdowns. You will practice changes that keep users online while software and nodes change underneath them.

Use Horizontal Pod Autoscalers, Vertical Pod Autoscalers, Cluster Autoscaler, and event-driven scaling with KEDA. You will match scaling signals to real workloads and avoid unstable feedback loops.

Use Service meshes such as Istio, Linkerd, or Cilium service mesh for traffic policy, mTLS, retries, timeouts, and service-to-service visibility. You will decide when a mesh solves real problems and when it adds too much complexity.

Use container image signing, vulnerability scanning, SBOMs, provenance, and trusted registries. This chapter covers the modern supply-chain risks that affect Kubernetes clusters before a Pod ever starts.

Use eBPF-powered networking, observability, and security tools to inspect behavior with less overhead and deeper kernel visibility. You will see why eBPF changed how many teams troubleshoot and protect clusters.

Run Knative-style services, event-driven workloads, and scale-to-zero patterns on Kubernetes. You will learn where serverless on Kubernetes fits and where plain Deployments or cloud functions are simpler.

Use managed Kubernetes services, node pools, load balancers, cloud storage, identity integration, and cluster upgrades. You will compare what the cloud provider manages with what your team still owns.

Plan cluster upgrades, node replacement, backups, certificate rotation, etcd protection, and disaster recovery drills. This chapter focuses on the operational chores that keep a cluster trustworthy over time.

Separate teams and environments with namespaces, quotas, limit ranges, network boundaries, and access policies. You will design shared clusters that reduce waste without letting teams break each other.

Manage fleets with multi-cluster networking, placement, identity, policy, and deployment strategies. You will cover regional resilience, edge clusters, tenant separation, and the tradeoffs of running more than one cluster.

Connect Kubernetes to compliance needs such as audit logs, change records, encryption, secret handling, incident evidence, and retention. You will turn regulatory and customer requirements into practical cluster controls.

Work through real incidents: CrashLoopBackOff, ImagePullBackOff, failed scheduling, broken Ingress, DNS failures, storage mount problems, and noisy neighbors. You will build a repeatable path from symptom to root cause to safe fix.

Build a production-ready platform for a sample organization, including app delivery, access control, observability, policies, scaling, backups, and upgrade plans. This capstone makes you justify design choices instead of only applying commands.

Map Kubernetes roles such as platform engineer, SRE, DevOps engineer, cloud engineer, and security engineer. You will plan proof-of-skill projects, choose useful certifications such as KCNA, CKA, CKAD, or CKS, and follow SIGs, releases, CVEs, and community practices to stay current.