Kubernetes Deep Dive
by Sergey Okinchuk
Ch. 1

Kubernetes Deep Dive

Welcome

A practical, first-principles guide to Kubernetes — what each object does, how the pieces fit together, when to reach for it, and where the failure modes are.

14 chapters 70 topics covered 6 hours audio 4 case studies Knowledge check on every topic

About This Course

Kubernetes has a reputation for being hard. Part of that is real — it is a large system with many moving parts. Most of it is the way it is usually taught: introductions either drop you into YAML before you know what the objects are for, or stay so high-level that you finish knowing the words but not how anything fits together.

This course takes a different path. It explains Kubernetes from first principles, in plain language, in the order that makes the pieces click. It starts with what a container actually is and the one idea the whole system rests on — declarative desired state — then builds up the core objects, then networking, security, scaling, and the parts of running a cluster that bite you in production.

Each topic is covered with consistent structure: what it is, how it works, when to use it, when not to, the common mistakes, and the best practices. Where two approaches compete, the course compares them and says when each one fits rather than leaving that work to you.

Who This Is For

Engineers who run or build on Kubernetes, and those preparing to. The beginner can read it in order to build a mental model from zero; the experienced engineer can jump to a chapter to fill a gap or settle a decision. It assumes you are comfortable on the Linux command line and have met containers, but it does not assume any prior Kubernetes.

What You Should Already Know

  • Linux basics — processes, files, environment variables, and comfort in a shell
  • Containers at a basic level — what an image is and roughly how docker run works
  • HTTP, TLS, and DNS at the level of what they do, not how they are implemented
  • What a load balancer is and the shape of a web request
  • No prior Kubernetes experience required

How the Course Is Built

The fourteen chapters are grouped so the early ones teach the core and the later ones build on it. Foundations and the core objects come first, then storage, networking, scheduling, and security. The later chapters cover extending Kubernetes, packaging and delivery, observability, running a cluster, the managed offerings, and the architecture, case studies, and best practices that turn the parts into systems.

A few principles run through every chapter. They are worth stating up front, because they explain why the course is shaped the way it is.

Understand before you apply
Kubernetes rewards a mental model over memorized commands. Every object in this course is explained from what problem it solves before how to configure it.
Declarative over imperative
You describe desired state and let the reconcile loop converge on it. Most of the platform's power — and its surprises — follow from that one idea.
The trade-offs are the point
A feature that is excellent for one workload is a poor fit for another. The course says so, and explains when not to reach for something.
Production is operations
A cluster you can trust differs from a demo mostly in the unglamorous work: limits, probes, backups, upgrades, and budgets. That work gets its own chapters.

Chapter Map

Chapter 1
Foundations
What Kubernetes is and the idea that makes it click: you declare desired state and a control loop keeps reality matching it. Containers, the runtime chain, the control plane and nodes, and how you talk to it all.
Chapter 2
Workloads and Core Objects
The objects you touch daily: Pods and the controllers that manage them, labels and Services, Ingress and the Gateway API, configuration and secrets, and the workload kinds — Jobs, DaemonSets, StatefulSets, and sidecars.
Chapter 3
Storage
Durable storage for ephemeral Pods: Volumes, the PersistentVolume / PersistentVolumeClaim split that decouples request from supply, StorageClasses for dynamic provisioning, and the Container Storage Interface.
Chapter 4
Networking
The network model that makes Pods addressable, cluster DNS and service discovery, the CNI plugins that implement it, NetworkPolicies for segmentation, and the layer a service mesh adds on top.
Chapter 5
Scheduling and Scaling
Where Pods land and how many run: resource requests and limits, the scheduler's placement logic, the horizontal and vertical and cluster autoscalers, health probes, and disruption budgets with Quality of Service.
Chapter 6
Security
Cluster security end to end: how requests authenticate and authorize, RBAC and service accounts, Pod Security Standards, encrypting secrets at rest, admission control and policy engines, and image and supply-chain security.
Chapter 7
Extending Kubernetes
Kubernetes as a platform you extend: Custom Resource Definitions that add your own object kinds, the operator pattern that encodes operational knowledge as a controller, and the broader ways to extend the API.
Chapter 8
Packaging and Delivery
From repo to running cluster: templating and releases with Helm, overlay-based config with Kustomize, the GitOps model with Argo CD and Flux, and the CI/CD pipelines that tie it together.
Chapter 9
Observability
Seeing inside a running cluster: log collection, metrics and monitoring with Prometheus and Grafana, distributed tracing with OpenTelemetry, and a practical guide to events, debugging, and troubleshooting.
Chapter 10
Cluster Operations
Operating a cluster over its life: installing with kubeadm, running and backing up etcd, upgrades and node maintenance, multi-tenancy with quotas, and keeping cluster cost under control.
Chapter 11
Managed Kubernetes
Letting a cloud run the control plane: what managed Kubernetes covers and what it doesn't, the three big offerings — Amazon EKS, Google GKE, Azure AKS — and how to choose between self-managed and managed.
Chapter 12
Architecture and Patterns
Designing systems, not objects: the application patterns Kubernetes encourages, multi-cluster and multi-region topologies, and what real high availability and disaster recovery require.
Chapter 13
Case Studies
The material assembled into real workloads: a web SaaS platform, a data and machine-learning platform, a monolith migration, and a multi-tenant internal platform — each with the trade-offs it forced.
Chapter 14
Best Practices and Anti-Patterns
What separates a demo from production: a production-readiness checklist, security best practices, cost and efficiency, reliability and SRE practices, and a catalog of the anti-patterns that recur across all of them.

Disclaimer

This course is an independent educational project created and maintained by Sergey Okinchuk. It is provided for learning and reference purposes only.

No affiliation. This course is not affiliated with, sponsored by, endorsed by, or officially connected to The Linux Foundation, the Cloud Native Computing Foundation (CNCF), or any company or project mentioned. All opinions, interpretations, and recommendations expressed are those of the author.

Trademarks. "Kubernetes" is a registered trademark of The Linux Foundation. CNCF and the names of cloud-native projects, along with "AWS", "Amazon EKS", "Google Cloud", "GKE", "Azure", and "AKS", are trademarks of their respective owners. Use of these names and marks is for identification and educational purposes only and does not imply any endorsement.

Logo and icon attribution. The Kubernetes logo and the per-topic icons used throughout this course are reproduced from the official Kubernetes icon set and CNCF artwork under their respective licenses, for educational and editorial purposes. Cloud provider icons belong to their respective owners.

Accuracy and currency. Kubernetes evolves quickly — it ships roughly three releases a year, and API versions, defaults, feature maturity, and command-line flags drift. Facts in this course reflect the author's understanding at the time of writing and may not be current. Always consult the official Kubernetes documentation as the authoritative source before making operational decisions.

No warranty. This material is provided "as is" without warranty of any kind. Manifests and commands are illustrative, not production-ready. The author accepts no liability for any loss or damage arising from reliance on the content.