Back to Exploration Map
☸️
Course

Practical Kubernetes with k3s

🐧 Linux-based⚡ Hands-on labs +1910 XP

Course Description

From One Container to a Self-Healing Cluster

You can containerize an app and run it with Docker Compose — on one machine, by hand. But what happens when that machine reboots, a container dies at 3am, or you need to ship a new version with zero downtime? This course is the answer. You’ll stand up a real, production-grade Kubernetes cluster on your own Linux box with k3s and learn how orchestration actually works — not by memorizing commands, but by watching the cluster heal, scale, and deploy for you.

Everything runs on your own machine. You’ll go from a single node to a two-machine cluster, deploy a full multi-tier app, and ship a zero-downtime rolling update to it — the payoff for every concept along the way. It’s taught k3s-first but distro-agnostic, so the skills transfer straight to microk8s, minikube, or a managed cloud cluster like EKS, GKE, or AKS.

What You’ll Learn

  • The declarative desired-state model and the control loop — the one idea the whole system is built on
  • The control plane vs the nodes, and why every command goes through the API server
  • Stand up a real cluster in one command with k3s, then drive it with core kubectl
  • Pods, Deployments, and ReplicaSets — and watch the cluster self-heal and scale on command
  • Write declarative YAML manifests and treat them as your source of truth with kubectl apply
  • Expose apps with Services (ClusterIP, NodePort, LoadBalancer), cluster DNS, and Ingress (Traefik)
  • Configure apps with ConfigMaps and Secrets — including the honest base64 caveat
  • Give data a home with persistent volumes (PVCs) and run databases as StatefulSets
  • Operate like production: health probes, resource requests & limits, and rolling updates & rollbacks
  • Partition a cluster with namespaces and debug broken Pods — CrashLoopBackOff, OOMKilled, and friends
  • Add a second node, watch the scheduler spread work across machines, and meet Helm, Jobs, and CronJobs

How You’ll Learn

Every lesson is built around running the real thing yourself:

  • Build up one real cluster on your own machine, lesson by lesson — no toy simulator
  • Break things on purpose — delete Pods, blow a memory limit, ship a bad image — and watch Kubernetes react
  • Lock in each concept with a quick quiz
  • Finish with a capstone: deploy a full multi-tier app — web, database, config, secrets, storage, and Ingress — then roll out a new version with zero downtime

You won’t just read about Kubernetes — you’ll install it, break it, scale it, and ship to it.

Where This Fits Your Journey

This is the orchestration capstone of the BytExplorer DevOps path: own Linux → version with Git → containerize with Docker → serve & secure with Nginx → monitor with Prometheus → automate with GitLab CI/CD → orchestrate with Kubernetes.

Recommended first: Practical Docker on Linux (Kubernetes runs and orchestrates the containers you already know), with Linux Essentials for terminal comfort and Nginx HTTPS handy for the Ingress lessons.

After this course, “it works on my machine” becomes “it runs across a cluster, heals itself, and updates with zero downtime.” You’ll understand real Kubernetes — not a managed dashboard you poke at, but the system underneath it.

Ready to orchestrate? Let’s build your cluster.

Get full access

This course — plus every other BytExplorer course — hands-on, on your own machine.

$29/mo · all courses included · cancel anytime

What's Included
  • Hands-on labs on your own Linux machine
  • Commented source code you can learn from
  • Quick quizzes to lock in each concept
  • Every project's source is yours to download and keep
  • Earn XP and level up as you go

Hands-on throughout. You won't just watch — you'll build, break, and fix real deployments.

Related guides

Free explainers and fixes that pair with this course.

🧱
Pods vs Deployments vs ReplicaSets in Kubernetes
Three Kubernetes objects that constantly get confused — and a clean way to keep them straight. A Pod runs your container, a ReplicaSet keeps copies alive, and a Deployment manages the whole thing so you get rolling updates for free.
🔐
ConfigMaps vs Secrets in Kubernetes
Both pull configuration out of your container image so one image runs anywhere. The split is simple — ConfigMaps for ordinary settings, Secrets for sensitive ones — but there's one honest caveat about Secrets everyone should know.
🔀
Kubernetes Services: ClusterIP vs NodePort vs LoadBalancer
Pods come and go, and their IPs change every time. A Service is the stable front door that always points at the right ones. The only real decision is who needs to reach it — and that's what the three types are for.
⏳
Kubernetes Pod Stuck in Pending (FailedScheduling)
A pod stuck in Pending hasn't been placed on any node yet — the scheduler looked and found nowhere to put it. The events tell you exactly why, and it's usually resources, taints, or an unbound volume.
🚦
Kubernetes Ingress Returns 404 Not Found
A 404 from your Ingress usually isn't your app answering — it's the ingress controller saying "no rule matched this request." The cause is almost always the host, the path, or a backend that has no endpoints.
📦
Kubernetes ImagePullBackOff and ErrImagePull: How to Fix
ImagePullBackOff means Kubernetes never even got your container image — so nothing else can start. It's almost always a wrong name, a missing tag, or a private registry with no credentials. Here's how to tell which.

Frequently asked questions

What background do I need for Kubernetes?

Docker and basic Linux (our Docker course is the ideal lead-in). Kubernetes builds on containers, so that grounding matters.

What will I build?

A real Kubernetes cluster with k3s — self-healing, multi-node, running a zero-downtime, multi-tier deployment on machines you control.

Is this a real cluster or a managed dashboard?

A real cluster you stand up yourself with k3s — not a managed cloud dashboard — so you understand what is actually happening under the hood.