What is Kubernetes? The Complete Plain-English Guide for Self-Hosters

By Seth Sanders | 12-Year IT Systems Engineer & Systems Administrator Veteran

If you hang around homelab communities or IT discussions long enough, you will inevitably run into Kubernetes (often abbreviated as K8s—the "8" stands for the eight letters between the "K" and the "s").

While Docker revolutionized how we package and run self-hosted applications, Kubernetes takes things a step further. It is the gold standard for container orchestration—a platform designed to manage, scale, and repair automated container fleets across single servers or multi-node clusters.

Whether you're deciding if K8s belongs in your home lab or trying to understand how modern IT production environments work, this guide covers what Kubernetes actually is, how it functions under the hood, and whether you should run it yourself.

The Evolution: Bare-Metal to Containers to Orchestration

To understand why Kubernetes exists, it helps to see how server administration evolved over the last two decades:

┌─────────────────┐      ┌─────────────────┐      ┌─────────────────┐
│  Physical App   │      │ Virtual Machine │      │ Docker Container│
├─────────────────┤      ├─────────────────┤      ├─────────────────┤
│    OS Kernel    │      │    Guest OS     │      │   App Binaries  │
├─────────────────┤      ├─────────────────┤      ├─────────────────┤
│ Bare-Metal Host │      │   Hypervisor    │      │ Container Engine│
└─────────────────┘      └─────────────────┘      └─────────────────┘
  Bare-Metal Era           Virtualization Era        Container Era

That is where Kubernetes comes in. It sits on top of your machines and manages container health, networking, storage, and scaling automatically.

Core Kubernetes Architecture

Kubernetes turns a pool of physical or virtual machines into a single, cohesive computing unit. A Kubernetes cluster consists of two primary layers:

                     ┌────────────────────────────────────────┐
                     │          CONTROL PLANE (Brain)         │
                     │  ┌──────────┐ ┌──────────┐ ┌────────┐  │
                     │  │ kube-api │ │   etcd   │ │ sched  │  │
                     │  └──────────┘ └──────────┘ └────────┘  │
                     └───────────────────┬────────────────────┘
                                         │
                 ┌───────────────────────┴───────────────────────┐
                 │                                               │
                 ▼                                               ▼
┌─────────────────────────────────┐             ┌─────────────────────────────────┐
│          WORKER NODE 1          │             │          WORKER NODE 2          │
│  ┌─────────┐  ┌──────────────┐  │             │  ┌─────────┐  ┌──────────────┐  │
│  │ kubelet │  │  Containerd  │  │             │  │ kubelet │  │  Containerd  │  │
│  └─────────┘  └──────────────┘  │             │  └─────────┘  └──────────────┘  │
│  ┌───────────────────────────┐  │             │  ┌───────────────────────────┐  │
│  │   Pod (Your App / Nginx)  │  │             │  │   Pod (Your App / Postgres)│  │
│  └───────────────────────────┘  │             │  └───────────────────────────┘  │
└─────────────────────────────────┘             └─────────────────────────────────┘

1. The Control Plane (The Brain)

The Control Plane makes global decisions about the cluster, detects node failures, and schedules workloads:

2. Worker Nodes (The Muscle)

Worker nodes are the physical machines or VMs that run your actual applications:

Key Kubernetes Terminology Decoded

If you are coming from standard Docker, the terminology changes slightly:

What Makes Kubernetes So Powerful?

Declarative Infrastructure ("Desired State")

In standard script-based administration, you issue step-by-step imperatives: "Download this file, restart that process, attach this drive."

Kubernetes uses Declarative Configuration (typically written in YAML files). You define your Desired State:

"I want 3 instances of Nextcloud running, connected to this persistent storage, auto-restarting if they crash."

Kubernetes continually runs a reconciliation loop. If a physical node dies and takes down one of your Nextcloud instances, Kubernetes notices that current state (2) does not match desired state (3), and automatically spins up a replacement instance on a surviving node within seconds.

Zero-Downtime Rolling Updates

When updating an application, Kubernetes spins up the new version alongside the old version, runs health checks, gracefully shifts web traffic over, and terminates the old version—eliminating deployment downtime.

Docker Compose vs. Kubernetes: Which Do You Need?

Feature Docker Compose Kubernetes (K8s)
Primary Scope Single host machine Multi-node cluster
Learning Curve Gentle (Minutes/Hours) Steep (Days/Weeks)
Node Failover None (If host dies, apps go down) Automatic self-healing and rescheduling
Auto-Scaling Manual Automatic (HPA based on CPU/RAM)
Best For Homelabs, single mini-PCs, hobby projects High availability, enterprise production, multi-server fleets

Modern Lightweight Kubernetes for Homelabs

If you decide to experiment with Kubernetes in your home lab, you don't need a massive cluster of servers. Lightweight, resource-efficient distributions run on small mini-PCs, single-board computers, or VMs:

Summary

Kubernetes is the backbone of modern cloud computing. While it introduces significant complexity that a simple home lab may not always require, understanding its core mechanics gives you a massive advantage in modern system administration, DevOps, and self-hosted infrastructure design.