Skip to content

Exploring Kubernetes

Exploring Kubernetes

From first deployment to production operations.

Your manager just said "we're using Kubernetes now." Or you saw it on a job description. Or your team adopted it and you're expected to figure it out.

This site gets you there — from "what even is this?" through deploying your first application, to running production clusters with confidence. Every article starts with a real scenario you'll recognize and builds toward genuine understanding, not just memorized commands.

A subsection of BradPenney.io, written from years of production Kubernetes experience.

Learning Path

Day One: Getting Started

Everyone starts here. Two articles establish the foundation, then you choose the deployment path that matches how your team works.

Start with these:

Then choose your path:

Both Paths Converge at Level 1

Whether you start from scratch with kubectl or with Helm charts, both paths land in the same place: running Pods, stable Services, and the confidence to deploy and debug. Level 1 is where everyone deepens their understanding of the same core Kubernetes primitives.

Level 1: Core Primitives

Building on Day One. Master the fundamental Kubernetes building blocks you'll use in every deployment.

  • Pods Deep Dive

    The atomic unit of Kubernetes — what a Pod is, why it exists, multi-container sidecars, init containers, the Pod lifecycle, and CrashLoopBackOff explained.

  • Services: Stable Networking for Pods

    Why Pod IPs are unreliable and how Services solve it — ClusterIP, NodePort, LoadBalancer types, DNS service discovery, and kubectl port-forward for local testing.

  • ConfigMaps and Secrets (coming soon)

    Decoupling configuration from your container images — environment variables, mounted config files, and managing sensitive data.

  • Namespaces (coming soon)

    Logical separation, resource quotas, working across namespaces.

  • Labels and Selectors (coming soon)

    The "glue" of Kubernetes — organizing and targeting resources, filtering, best practices.

Levels 2–6: The Full Journey

  • Level 2 — Workload Management (coming soon)

    For: App developers deploying real applications

    Deployments, ReplicaSets, StatefulSets, DaemonSets, Jobs and CronJobs

  • Level 3 — Networking (coming soon)

    For: App developers + Platform engineers

    Ingress controllers, Network Policies, DNS and service discovery, troubleshooting

  • Level 4 — Storage and State (coming soon)

    For: Stateful applications and platform engineers

    Persistent Volumes, PVCs, StorageClasses, volume types

  • Level 5 — Advanced Scheduling & Security (coming soon)

    For: Platform engineers

    Resource requests and limits, Taints and Tolerations, RBAC, Pod Security

  • Level 6 — Production Operations (coming soon)

    For: SREs and platform engineers

    Logging architecture, Monitoring and metrics, Health probes, Operators

Your Learning Journey

flowchart TD
    Start["Application Developer<br/>kubectl access · first deployment"]
    D1["✅ Day One: Getting Started<br/>kubectl path or Helm path"]
    L1["✅ Level 1: Core Primitives<br/>Pods · Services"]
    L2["Level 2: Workload Management<br/>Deployments · StatefulSets · DaemonSets"]
    L34["Levels 3–4: Networking & Storage<br/>Ingress · Network Policies · PV · PVC"]
    L56["Levels 5–6: Security & Production Ops<br/>RBAC · Monitoring · Operators"]
    End["Platform Engineer<br/>Production clusters · confident & capable"]

    Start --> D1
    D1 --> L1
    L1 --> L2
    L2 --> L34
    L34 --> L56
    L56 --> End

    style Start fill:#2d3748,stroke:#cbd5e0,stroke-width:2px,color:#fff
    style D1 fill:#2f855a,stroke:#cbd5e0,stroke-width:2px,color:#fff
    style L1 fill:#2f855a,stroke:#cbd5e0,stroke-width:2px,color:#fff
    style L2 fill:#4a5568,stroke:#cbd5e0,stroke-width:2px,color:#fff
    style L34 fill:#4a5568,stroke:#cbd5e0,stroke-width:2px,color:#fff
    style L56 fill:#4a5568,stroke:#cbd5e0,stroke-width:2px,color:#fff
    style End fill:#1a202c,stroke:#cbd5e0,stroke-width:2px,color:#fff

Day One and Level 1–2 assume you're an application developer with:

  • Access to a real development cluster (your platform team set this up)
  • An application to deploy — or vendor software to install
  • Limited command-line experience
  • No Kubernetes knowledge yet

The reality this site acknowledges: Your company adopted Kubernetes. Your teammates are figuring it out alongside you. Nobody expects you to be an expert — just functional enough to deploy your code and debug when things break.

This site gets you unblocked. Not certified, not expert-level — capable enough to ship confidently.

Level 3–6 shift to platform engineering concerns:

  • Networking and traffic management (Ingress, Network Policies, service mesh)
  • Storage and persistent state (PV, PVC, StorageClasses, StatefulSets)
  • Resource management and scheduling (Requests, Limits, Taints, Affinity)
  • Production operations (Logging, Monitoring, Helm at scale, Operators)

By Level 6, you'll be designing and running production Kubernetes clusters with confidence — making architectural decisions rather than just following instructions.

Philosophy

  • Progressive Depth, Not Repetition

    Each level builds on the last without re-explaining what came before. Day One gets you deployed. Level 1 explains what that deployment actually created. Level 2 shows you how to manage it at scale. Cross-linked, not duplicated.

  • Why Before How

    Every resource type, every command — you'll understand why it exists before learning how to use it. Memorizing YAML is easy; knowing which resource to reach for and when is the skill that takes years without a guide like this.

  • Production Safety Throughout

    Commands are clearly labeled: ✅ read-only, ⚠️ modifies resources, 🚨 destructive. Namespace awareness is built into every hands-on section. Real cluster access assumed — because that's what you actually have.

  • Two Personas, One Journey

    Day One through Level 2 speaks directly to application developers: intimidated by the terminal, responsible for deploying their own code. Level 3–6 shifts to platform engineers: responsible for the cluster, making architectural decisions. The content meets you where you are.

Kubernetes runs on Linux. Configuration lives in YAML. The platform engineer who understands both is dangerous in the best way.

  • Exploring Linux

    The foundation under every Kubernetes cluster. Covers the command line, filesystem, permissions, systemd, shell scripting, and production Linux administration.

    Start with Day One: Getting Access if you're new to the terminal. The Processes and Pipes and Redirection articles are referenced throughout this site.

  • Exploring Python

    Python for infrastructure engineers — not data science, not web apps. Covers writing CLI tools, parsing logs, wrapping shell commands, and working with YAML and environment configuration.

    The YAML article is directly useful for Helm values.yaml and Kubernetes manifests. The Health Check article shows patterns you'll recognize from Kubernetes readiness probes.

  • Exploring Computer Science

    The CS theory that explains why Kubernetes works the way it does — without the academic jargon. Covers algorithms, data structures, and computational thinking from the perspective of working engineers.

    Finite State Machines explains Kubernetes' reconciliation loop. Type Systems makes sense of Kubernetes' strict API schema validation.

Connect