containers · automation · cloud · networking · storage

Kubernetes for Production Sysadmins

A production-first Kubernetes course for systems administrators, platform engineers and SREs. Covers the full Kubernetes curriculum: control-plane and worker architecture, the API model, reconciliation, objects, kubectl, declarative management, Pods, init containers and sidecars, requests/limits and QoS, namespaces, Deployments, StatefulSets, DaemonSets, Jobs and CronJobs, configuration and Secrets, scheduling and topology, taints and tolerations, kubelet, CRI, node lifecycle, drain and PodDisruptionBudgets, networking model, CNI, Services, Service discovery, CoreDNS, Ingress, Gateway API, NetworkPolicy, packet capture, MTU, storage, PVs and PVCs, StorageClasses, CSI, stateful workloads, snapshots, authentication, RBAC, ServiceAccounts, admission, Pod Security Standards, Linux security controls, supply chain, etcd, etcd quorum, etcd backup and restore, API server, scheduler, controller manager, control-plane HA, kubeadm, cluster certificates, upgrades, version skew, API deprecation, autoscaling, capacity planning, observability, kube-state-metrics, Metrics Server, Prometheus, logging, tracing, events, alerting, audit, backup strategy, Velero, disaster recovery, complete cluster loss, multi-cluster concepts, managed vs self-managed, GitOps, Helm, Kustomize, multi-tenancy, ResourceQuota, LimitRange, priority and preemption, advanced networking, bare-metal load balancing, DNS advanced troubleshooting, TLS, image registry, maintenance windows, change management, troubleshooting methodology, pod troubleshooting, Service troubleshooting, DNS troubleshooting, NetworkPolicy troubleshooting, node troubleshooting, control-plane troubleshooting, etcd incident response, storage troubleshooting, performance troubleshooting, security incident response, production anti-patterns, and a capstone mission-critical Kubernetes estate.

Start the course →Take the final assessment →See full curriculum Toolkit Knowledge checks

Who this is for

Systems administrators moving into container orchestration
Platform and infrastructure engineers responsible for production Kubernetes estates
Site Reliability Engineers owning application platforms
DevOps engineers deploying and operating container workloads
Cloud engineers managing Kubernetes-based infrastructure
Network engineers integrating with container networking
Security engineers auditing container platforms
Technical professionals responsible for business-critical Kubernetes workloads

Prerequisites

Comfortable on the Linux command line
Working knowledge of Linux networking
Familiar with Docker and container concepts
Working knowledge of TLS, DNS, and basic service networking
A disposable VM or Proxmox environment for the labs

Other RunBook Academy courses

Linux — recommended. Kubernetes is a Linux system; production work assumes comfort with the Linux networking stack, cgroups, namespaces, kernel modules, and process lifecycle the Linux course teaches in depth.
Docker & Containers — recommended. Kubernetes workloads are containers; the Docker course covers image construction, runtimes, registry interactions, and Linux container primitives Kubernetes inherits.
Observability — recommended. A production Kubernetes estate needs metrics, logs, traces and alerting; the Observability course teaches the stack Kubernetes clusters feed into.
Terraform — recommended. Production cluster builds, node pools, networking and storage are commonly provisioned with Terraform; the Terraform course covers the IaC patterns this course references.
Ansible — recommended. Common Kubernetes add-ons and node bootstrap are commonly driven by Ansible; the Ansible course covers the safe automation patterns this course references.
VyOS — recommended. Bare-metal Kubernetes networking builds on the routing and policy concepts the VyOS course teaches.

What you'll be able to do

After completing this course, you should be capable of independently:

Explain the Kubernetes control-plane architecture and how each component contributes to reconciliation
Operate the Kubernetes API: authentication, authorization, admission, watch, persistence in etcd
Apply the desired-state and reconciliation model to every Kubernetes resource
Author and review YAML manifests using spec-vs-status discipline
Use kubectl as an operational tool, not a memorised command list
Manage declarative workloads safely (apply, server-side apply, diff, field ownership)
Deploy, troubleshoot, and recover Pods across their full lifecycle
Configure resource requests and limits correctly and reason about QoS implications
Use Deployments, StatefulSets, DaemonSets and Jobs for the correct workload patterns
Apply ConfigMaps and Secrets with security and update-behaviour discipline
Place workloads using scheduling primitives: taints, tolerations, node affinity, pod affinity, topology spread
Troubleshoot Pending Pods through scheduler events, requests, affinity, taints, PVCs
Operate kubelet, CRI, container runtimes and the node lifecycle
Drain, maintain, and recover nodes without violating PodDisruptionBudgets
Reason about the Kubernetes networking model: Pod-to-Pod, Service, DNS, NetworkPolicy
Diagnose CNI, Service, DNS and NetworkPolicy failures with evidence
Operate CoreDNS, Ingress and Gateway API for cluster ingress and service discovery
Design and operate PVs, PVCs, StorageClasses and CSI for stateful workloads
Diagnose PVC Pending, attach and mount failures
Apply RBAC, ServiceAccounts, Pod Security Standards, and Linux security controls to workloads
Back up and restore etcd; recover a cluster from total control-plane loss
Plan, validate and execute Kubernetes control-plane and worker upgrades
Build, monitor and alert on a production Kubernetes estate
Respond to production incidents with evidence-first methodology
Recognise and remediate production anti-patterns

Curriculum overview

137 planned parts · 787 lessons currently published.

Part I

Container and Distributed Systems Foundations

Container and distributed systems foundations relevant to Kubernetes: namespaces, cgroups, containers, images, container runtimes, distributed systems, desired state, reconciliation.

6 lessons

Part II

Kubernetes Architecture

Control plane, workers, API server, etcd, scheduler, controller manager, kubelet, kube-proxy/service dataplane, container runtime, CNI, CSI.

6 lessons

Part III

Kubernetes API

Kubernetes as an API-driven system: kubectl, REST API, API server, authentication, authorization, admission, persistence in etcd.

6 lessons

Part IV

Desired State and Reconciliation

Desired state and reconciliation. The control loop that drives Kubernetes: observe, diff, act. Controllers and the convergence model.

6 lessons

Part V

Kubernetes Objects and Metadata

Resources: apiVersion, kind, metadata, spec, status, labels, annotations, selectors, owner references, finalizers. The spec-vs-status discipline.

6 lessons

Part VI

kubectl for Administrators

Operational kubectl: get, describe, logs, exec, explain, events, top, auth, config. JSON/YAML output, selectors, custom columns, server-side, debugging flags.

6 lessons

Part VII

Declarative Resource Management

Declarative resource management: manifests, apply, patch, delete, diff, field ownership, server-side apply, drift.

6 lessons

Part VIII

Pods

Pod lifecycle, containers, init containers, sidecars, restart policy, termination, lifecycle hooks, Pod IP, shared namespaces.

6 lessons

Part IX

Pod Lifecycle

Pod phases (Pending, Running, Succeeded, Failed, Unknown) and container states (Waiting, Running, Terminated). Why Running does not mean healthy.

6 lessons

Part X

Pod Termination and Signals

Pod deletion, preStop, SIGTERM, terminationGracePeriodSeconds, SIGKILL. Connection to Linux PID 1 and Docker lessons.

6 lessons

Part XI

Init Containers and Sidecars

Init containers, native sidecars (current semantics), legitimate design patterns, anti-patterns.

6 lessons

Part XII

Resource Requests and Limits

Resource requests and limits: CPU, memory, scheduling, cgroups, throttling, OOMKill, QoS classes.

6 lessons

Part XIII

Kubernetes QoS Classes

QoS classes: Guaranteed, Burstable, BestEffort. Eviction implications.

6 lessons

Part XIV

Namespace Architecture

Namespace architecture: logical isolation, RBAC, quota, policy, tenancy. Limitations of namespace isolation.

6 lessons

Part XV

Deployments

Deployments, ReplicaSets, rollout, revision, rolling updates, rollout status, rollback.

6 lessons

Part XVI

Deployment Strategies

Deployment strategies: RollingUpdate, Recreate, blue/green conceptually, canary conceptually, readiness, traffic management.

6 lessons

Part XVII

StatefulSets

StatefulSets: stable identity, ordered deployment, persistent storage, headless services, scaling, deletion implications.

6 lessons

Part XVIII

DaemonSets

DaemonSets: node-local agents, log collectors, networking agents, monitoring agents.

6 lessons

Part XIX

Jobs and CronJobs

Jobs and CronJobs: completion, parallelism, retries, deadlines, history, failed jobs.

6 lessons

Part XX

Configuration

ConfigMaps: environment variables, mounted configuration, update behaviour, immutable patterns.

6 lessons

Part XXI

Secrets

Kubernetes Secrets: base64 is not encryption, etcd storage, encryption at rest, RBAC, volume/environment exposure, external secret management.

6 lessons

Part XXII

Scheduling Fundamentals

Scheduling fundamentals: filters, scoring, binding, requests, constraints, topology.

6 lessons

Part XXIII

nodeSelector and Node Affinity

nodeSelector, node affinity: required, preferred, node placement.

6 lessons

Part XXIV

Pod Affinity and Anti-Affinity

Pod affinity and anti-affinity: co-location, separation, topology, HA examples.

6 lessons

Part XXV

Topology Spread Constraints

Topology spread constraints: distribution across nodes, racks, zones, resilience implications.

6 lessons

Part XXVI

Taints and Tolerations

Taints and tolerations: NoSchedule, PreferNoSchedule, NoExecute, dedicated nodes, node failure interactions.

6 lessons

Part XXVII

Scheduling Failures

Scheduling failure troubleshooting: CPU, memory, affinity, taints, PVC, topology, node selectors. The Pending Pod.

6 lessons

Part XXVIII

Node Architecture

Node architecture: kubelet, container runtime, CNI, kube-proxy, Pods. Node object vs physical/virtual host.

6 lessons

Part XXIX

kubelet

kubelet: Pod lifecycle, probes, runtime, status, volumes, node registration.

6 lessons

Part XXX

Container Runtime and CRI

Container Runtime and CRI: containerd, image pulls, runtime failures.

6 lessons

Part XXXI

Node Lifecycle

Node lifecycle: Ready, NotReady, Unknown, heartbeats, leases, conditions, pressure.

6 lessons

Part XXXII

Node Pressure and Eviction

Node pressure and eviction: MemoryPressure, DiskPressure, PIDPressure.

6 lessons

Part XXXIII

Cordon, Drain and Uncordon

Cordon, drain, uncordon: DaemonSets, PDBs, local data, graceful disruption.

6 lessons

Part XXXIV

PodDisruptionBudgets

PodDisruptionBudgets: purpose, limitations, why PDBs do not guarantee availability.

6 lessons

Part XXXV

Kubernetes Networking Fundamentals

Kubernetes networking model: Pod-to-Pod, Pod-to-Service, external-to-Service, node traffic, cluster DNS.

6 lessons

Part XXXVI

CNI

CNI plugin responsibilities. Pod creation, kubelet, runtime, CNI, network namespace, interface, IP, routes.

6 lessons

Part XXXVII

Pod Networking

Pod networking: IP, routes, overlays, underlays, encapsulation, MTU.

6 lessons

Part XXXVIII

Services

Services: ClusterIP, NodePort, LoadBalancer, ExternalName. Virtual Service IPs.

6 lessons

Part XXXIX

Service Discovery

Service discovery: DNS, service names, namespaces, endpoints, EndpointSlices.

6 lessons

Part XL

kube-proxy and Service Dataplane

kube-proxy and the service dataplane: iptables, nftables, IPVS, eBPF variants.

6 lessons

Part XLI

CoreDNS

CoreDNS: service discovery, Kubernetes plugin, upstream DNS, caching, scaling, failure behaviour.

6 lessons

Part XLII

Ingress

Ingress: Ingress objects, controllers, host/path routing, TLS, implementation dependence.

6 lessons

Part XLIII

Gateway API

Gateway API: GatewayClass, Gateway, HTTPRoute, ownership separation, comparison with Ingress.

6 lessons

Part XLIV

NetworkPolicy

NetworkPolicy: default allow, default deny, ingress, egress, selectors, namespace selection, CNI enforcement dependence.

6 lessons

Part XLV

Kubernetes Networking Troubleshooting

Kubernetes networking troubleshooting: Application, Pod, Pod IP, CNI, Service, EndpointSlice, DNS, NetworkPolicy, node dataplane, external network.

6 lessons

Part XLVI

Packet Capture in Kubernetes

Packet capture in Kubernetes: node, Pod network namespace, debug containers, tcpdump.

6 lessons

Part XLVII

MTU Problems

MTU problems: overlay overhead, tunnels, VPN/cloud paths, fragmentation, PMTUD.

6 lessons

Part XLVIII

Storage Fundamentals

Storage fundamentals: application, PVC, StorageClass, CSI, storage platform.

6 lessons

Part XLIX

Volumes

Volumes: ephemeral vs persistent, lifecycle concepts.

6 lessons

Part L

PersistentVolumes and Claims

PersistentVolumes and Claims: PV, PVC, binding, capacity, access modes, reclaim policies.

6 lessons

Part LI

StorageClasses

StorageClasses: dynamic provisioning, provisioners, parameters, default classes.

6 lessons

Part LII

CSI

CSI architecture: controller, node plugin, provisioning, attach, mount.

6 lessons

Part LIII

Storage Failure Modes

Storage failure modes: PVC Pending, attach failure, mount failure, wrong access mode, node affinity, backend unavailable.

6 lessons

Part LIV

Stateful Workloads

Stateful workloads: application consistency, replication, backup, storage failure, application-specific HA.

6 lessons

Part LV

Storage Snapshots

Storage snapshots: CSI snapshots. Snapshot is not automatically application-consistent backup.

6 lessons

Part LVI

Kubernetes Security Foundations

Kubernetes security foundations: identities, authentication, authorization, admission, workload security, network isolation, secrets, supply chain.

6 lessons

Part LVII

Authentication

Authentication: client certificates, tokens, OIDC, ServiceAccounts. Avoiding deprecated mechanisms.

6 lessons

Part LVIII

RBAC

RBAC: Role, ClusterRole, RoleBinding, ClusterRoleBinding, verbs, resources, API groups. Privilege analysis examples.

6 lessons

Part LIX

kubectl auth

kubectl auth can-i and related inspection. Proving permissions.

6 lessons

Part LX

ServiceAccounts

ServiceAccounts: Pod identity, token projection, least privilege. Default ServiceAccount anti-patterns.

6 lessons

Part LXI

Admission Control

Admission control: mutating, validating, policies, webhooks, failure modes.

6 lessons

Part LXII

Pod Security Standards

Pod Security Standards: privileged, baseline, restricted.

6 lessons

Part LXIII

Linux Security Controls in Kubernetes

Linux security controls in Kubernetes: capabilities, seccomp, AppArmor/SELinux, runAsUser, runAsNonRoot, readOnlyRootFilesystem, privileged containers.

6 lessons

Part LXIV

Kubernetes Supply Chain Security

Kubernetes supply chain security: registries, image tags, digests, SBOM, vulnerability scanning, signatures, provenance, admission controls.

6 lessons

Part LXV

Secrets Security

Secrets security: etcd encryption, RBAC, auditability, external secrets, rotation.

6 lessons

Part LXVI

etcd

etcd: consensus, members, quorum, persistence, snapshots, performance, compaction, defragmentation.

6 lessons

Part LXVII

etcd Quorum

etcd quorum: control-plane HA, odd-member designs, why consensus matters.

6 lessons

Part LXVIII

etcd Backup

etcd backup: snapshot, secure storage, encryption, validation.

6 lessons

Part LXIX

etcd Restore

etcd restore: cluster restoration sequencing.

6 lessons

Part LXX

API Server

API server: endpoint, authentication, authorization, admission, etcd interaction, watch requests.

6 lessons

Part LXXI

Scheduler

Scheduler: filters, scoring, binding. Administrator-depth scheduling.

6 lessons

Part LXXII

Controller Manager

Controller manager: major controllers, reconciliation.

6 lessons

Part LXXIII

Control Plane High Availability

Control plane high availability: load balancer, control-plane nodes, etcd cluster, failure domains.

6 lessons

Part LXXIV

kubeadm

kubeadm: init, join, certificates, configuration, upgrades.

6 lessons

Part LXXV

Building a Production Cluster

Building a production cluster: control-plane sizing, worker sizing, HA, networking, storage, load balancer, DNS, time, certificates.

6 lessons

Part LXXVI

Cluster Certificates

Cluster certificates: certificates, expiry, kubeadm management, renewal, failure implications.

6 lessons

Part LXXVII

Kubernetes Upgrades

Kubernetes upgrades: release notes, deprecated APIs, etcd backup, control-plane upgrade, validate, drain worker, kubelet upgrade.

6 lessons

Part LXXVIII

Version Skew

Version skew: supported skew concepts, accurate rules, validation against official docs.

6 lessons

Part LXXIX

API Deprecation

API deprecation: how API removals break workloads during upgrade, detection tools, manifest review.

6 lessons

Part LXXX

Worker Node Upgrades

Worker node upgrades: drain, PDB, node capacity, kubelet, runtime, validation.

6 lessons

Part LXXXI

Cluster Autoscaling Concepts

Cluster autoscaling concepts: node autoscaling, workload scaling, capacity.

6 lessons

Part LXXXII

Horizontal Pod Autoscaler

Horizontal Pod Autoscaler: CPU, memory, custom/external metrics, requests dependency, stabilisation.

6 lessons

Part LXXXIII

Vertical Pod Autoscaling Concepts

Vertical Pod Autoscaling concepts: when appropriate, trade-offs.

6 lessons

Part LXXXIV

Resource Capacity Planning

Resource capacity planning: requests, actual usage, headroom, node failure capacity, system Pods, DaemonSets, evictions.

6 lessons

Part LXXXV

Cluster Observability

Cluster observability: API server, scheduler, controller manager, etcd, kubelet, nodes, Pods, workloads, CNI, CoreDNS.

6 lessons

Part LXXXVI

kube-state-metrics

kube-state-metrics: object-state metrics vs host/resource utilisation.

6 lessons

Part LXXXVII

Metrics Server

Metrics Server: purpose, limitations, relationship to kubectl top and HPA.

6 lessons

Part LXXXVIII

Prometheus Monitoring

Prometheus monitoring: Kubernetes service discovery, useful cluster signals. Cross-reference with Observability.

6 lessons

Part LXXXIX

Kubernetes Logging

Kubernetes logging: container stdout/stderr, node log paths, system components, collectors, metadata. Cross-reference Loki.

6 lessons

Part XC

Distributed Tracing

Distributed tracing: how Kubernetes infrastructure affects application traces. Cross-reference Tempo/OpenTelemetry.

6 lessons

Part XCI

Kubernetes Events

Kubernetes events: value and limitations. Not durable long-term logs.

6 lessons

Part XCII

Alerting

Alerting: high-value cluster alerts. Avoiding alert fatigue.

6 lessons

Part XCIII

Monitoring the Monitoring

Monitoring the monitoring: cluster observability stack resilience.

6 lessons

Part XCIV

Audit Logging

Audit logging: purpose, policy, security, volume, retention.

6 lessons

Part XCV

Backup Strategy

Backup strategy: cluster state, workload manifests, Git, etcd, persistent data, secrets, certificates, external dependencies.

6 lessons

Part XCVI

Workload Backup

Workload backup: application-consistent data, CSI snapshots, database-specific backups, object storage.

6 lessons

Part XCVII

Kubernetes Backup Tools

Kubernetes backup tools: Velero and others. Principles first.

6 lessons

Part XCVIII

Disaster Recovery

Disaster recovery: complete control-plane loss, recovery architecture.

6 lessons

Part XCIX

Complete Cluster Loss

Complete cluster loss: new infrastructure, control plane, networking, storage, cluster state, workloads, persistent data, validation.

6 lessons

Part C

Multi-Cluster Concepts

Multi-cluster concepts: environment isolation, blast radius, region/cluster boundaries, fleet management.

6 lessons

Part CI

Cluster Boundaries

Cluster boundaries: environment, security, geography, failure domain, compliance, scale.

6 lessons

Part CII

Managed vs Self-Managed Kubernetes

Managed vs self-managed Kubernetes: kubeadm vs managed control planes, responsibility differences.

6 lessons

Part CIII

GitOps Introduction

GitOps introduction: Git desired state, controller, cluster reconciliation.

6 lessons

Part CIV

Helm

Helm: charts, values, releases, templates, upgrade, rollback, repositories.

6 lessons

Part CV

Kustomize

Kustomize: overlays, declarative customisation, comparison with Helm.

6 lessons

Part CVI

Package Management Anti-Patterns

Package management anti-patterns: giant values files, unpinned charts, blindly installing public charts, configuration drift.

6 lessons

Part CVII

Namespaces and Multi-Tenancy

Namespaces and multi-tenancy: RBAC, NetworkPolicy, quotas, limits, workload separation. Limitations of soft multi-tenancy.

6 lessons

Part CVIII

ResourceQuota

ResourceQuota: CPU, memory, object counts, storage.

6 lessons

Part CIX

LimitRange

LimitRange: defaults and constraints.

6 lessons

Part CX

Priority and Preemption

Priority and preemption: workload priority, risks.

6 lessons

Part CXI

Kubernetes Networking Advanced Topics

Kubernetes networking advanced: eBPF dataplanes, Cilium concepts, BGP service advertisement, advanced policy.

6 lessons

Part CXII

Load Balancing on Bare Metal

Load balancing on bare metal: external load balancer, BGP-based advertisement, MetalLB.

6 lessons

Part CXIII

Kubernetes DNS Advanced Troubleshooting

Kubernetes DNS advanced troubleshooting: CoreDNS, upstream resolvers, search paths, ndots, DNS latency, service names.

6 lessons

Part CXIV

Certificate and TLS Operations

Certificate and TLS operations: API certificates, ingress certificates, application TLS, cert-manager.

6 lessons

Part CXV

Image Registry Operations

Image registry operations: private registries, credentials, imagePullSecrets, unavailable registries, tag/digest strategy.

6 lessons

Part CXVI

Maintenance Windows

Maintenance windows: pre-check, capacity, PDB, drain, change, validate, uncordon, observe.

6 lessons

Part CXVII

Change Management

Change management: manifests, Git, review, diff, staging, rollback, validation.

6 lessons

Part CXVIII

Kubernetes Troubleshooting Methodology

Kubernetes troubleshooting methodology: define symptom, determine impact, inspect object, events, logs, dependencies, identify component, hypothesis, test, restore, validate.

6 lessons

Part CXIX

Pod Troubleshooting

Pod troubleshooting: Pending, CrashLoopBackOff, ImagePullBackOff, CreateContainerConfigError, OOMKilled, probe failure.

6 lessons

Part CXX

Deployment Troubleshooting

Deployment troubleshooting: unavailable replicas, broken selectors, failed rollout, readiness failure, bad image.

6 lessons

Part CXXI

Service Troubleshooting

Service troubleshooting: client, DNS, Service, EndpointSlice, Pod IP, application port.

6 lessons

Part CXXII

DNS Troubleshooting

DNS troubleshooting: CoreDNS and application DNS path.

6 lessons

Part CXXIII

NetworkPolicy Troubleshooting

NetworkPolicy troubleshooting: policy isolation.

6 lessons

Part CXXIV

Node Troubleshooting

Node troubleshooting: NotReady, kubelet, runtime, CNI, disk pressure, memory pressure, certificates.

6 lessons

Part CXXV

Control Plane Troubleshooting

Control plane troubleshooting: API server, etcd, scheduler, controller manager.

6 lessons

Part CXXVI

etcd Incident Response

etcd incident response: member failure, latency, space pressure, quorum loss, certificate problems.

6 lessons

Part CXXVII

Storage Troubleshooting

Storage troubleshooting: PVC Pending, attachment, mount, CSI, backend.

6 lessons

Part CXXVIII

Application Performance Troubleshooting

Application performance troubleshooting: distinguishing application, cluster, node, storage, network, dependency.

6 lessons

Part CXXIX

Security Incident Response

Security incident response: suspicious Pod, leaked ServiceAccount token, privileged container, malicious image, compromised node, exposed API.

6 lessons

Part CXXX

Production Anti-Patterns

Production anti-patterns: latest tags, no requests, no probes, no PDB, privileged workloads, default SA everywhere, secrets in manifests, no NetworkPolicies, no backup, no etcd test, manual edits, no monitoring, all replicas on one node.

6 lessons

Part CXXXI

Production Reference Architecture

Production reference architecture: HA control plane, multi-worker, production networking, cluster DNS, persistent storage, application Deployment, stateful workload, ConfigMaps, Secrets, requests/limits, probes, affinity/spread, PDB, Services, Ingress/Gateway, TLS, NetworkPolicies, RBAC, workload security, monitoring, logging, tracing, backup, etcd backup, restore, rolling deployment, worker maintenance, Kubernetes upgrade, failure recovery.

7 lessons

Part Labs

Hands-On Labs

Disposable-virtualisation labs covering kubeadm, Pods, Deployments, Services, networking, storage, security, observability, backup, recovery.

0 lessons

Part Runbooks

Operational Runbooks

Operational procedures: deploy, troubleshoot, change, fail over, restore, recover.

0 lessons

Part Checklists

Production Checklists

Printable readiness, change, and review checklists.

0 lessons

Part Break/Fix

Break/Fix Scenarios

Deliberate operational incidents with evidence-first diagnosis.

0 lessons

Part Capstone

Capstone: Mission-Critical Kubernetes

A complete production Kubernetes estate with HA control plane, multi-worker, stateful workloads, RBAC, NetworkPolicies, monitoring, backup, and validated DR.

0 lessons

Part Final

Final Assessment

Theory and practical assessment of every production competency.

0 lessons

Verified against

Kubernetesv1.34.x· released 2025-08-27· verified 2026-08-16
kubeadmv1.34.x· verified 2026-08-16
kubectlv1.34.x· verified 2026-08-16
etcdv3.6.x· verified 2026-08-18
CoreDNSv1.11.x· verified 2026-08-16
containerdv1.7.x / 2.x· verified 2026-08-16