How to Set Up a Free Kubernetes Cluster on Proxmox

Why Build a Kubernetes Homelab Instead of Using the Cloud

Managed Kubernetes on AWS (EKS), GCP (GKE), or Azure (AKS) costs $70–150/month for a minimal cluster. For learning, exam preparation, or experimentation, that cost adds up fast.

A kubernetes homelab setup on Proxmox costs nothing to run if the hardware is already available — and secondhand machines capable of running a full multi-node cluster are available for $100–200.

Beyond cost, a self-managed cluster teaches things that managed services hide: control plane operations, kubeadm, etcd, networking, and troubleshooting at a level that cloud-managed K8s abstracts away entirely. This depth is exactly what the CKA exam tests.

This guide walks through building a production-grade three-node Kubernetes cluster on Proxmox VE from scratch.

Proxmox VE makes it easy to run multiple VMs on a single physical machine — perfect for K8s nodes

What Is Proxmox and Why Use It

Proxmox VE is a free, open-source virtualization platform built on Debian Linux. It supports both KVM virtual machines and LXC containers, with a full web interface for management.

Choosing Proxmox over alternatives like VirtualBox or VMware Workstation offers several advantages for a Kubernetes homelab:

• Free and enterprise-grade — the same platform used in production data centers
• Efficient resource usage — KVM VMs have near-native performance
• Snapshots and backups — restore a broken cluster in minutes
• Network management — configurable bridges and VLANs for realistic networking practice
• Web UI — manage everything from a browser without additional tooling

Hardware Requirements

The minimum viable setup for a three-node K8s cluster:

Spec	Minimum	Recommended
CPU	4 cores	6–8 cores
RAM	16GB	32GB
Storage	256GB SSD	512GB SSD
Network	1Gbps	1Gbps

A mini PC or small form factor machine in the $100–200 range on the secondhand market handles this comfortably. Look for machines with at least 4 cores and 16GB RAM.

Step 1 — Install Proxmox VE

Download the Proxmox VE ISO from proxmox.com. Flash it to a USB drive using Balena Etcher or dd, then boot the physical machine from USB.

The installer is straightforward. Choose your installation disk, set a root password and email address, and configure the network with a static IP on your local network.

After installation, access the Proxmox web interface at:

https://YOUR_SERVER_IP:8006

Log in as root with the password set during installation. Ignore the “no valid subscription” notice — Proxmox is fully functional without a paid subscription for homelab use.

Step 2 — Create Three Virtual Machines

Create three VMs for the Kubernetes cluster. Each VM needs its own resources:

VM	Role	vCPUs	RAM	Disk
k8s-master	Control Plane	2	4GB	32GB
k8s-worker1	Worker Node	2	6GB	32GB
k8s-worker2	Worker Node	2	6GB	32GB

In the Proxmox web UI:

1. Click Create VM
2. Set VM ID and name (101, 102, 103)
3. Select ISO: Ubuntu 22.04 LTS (download first to Proxmox ISO storage)
4. Set disk, CPU, and memory as per the table above
5. Set network to use the vmbr0 bridge (default)
6. Enable the QEMU Guest Agent

Install Ubuntu 22.04 LTS on each VM. Use the same username across all three — it simplifies Ansible automation later.

Set static IPs on all VMs and add hostname entries to /etc/hosts on each node:

192.168.1.100  k8s-master
192.168.1.101  k8s-worker1
192.168.1.102  k8s-worker2

Step 3 — Prepare All Nodes

Run these commands on every node (master and workers) before initializing the cluster.

Disable swap — Kubernetes requires swap to be off:

swapoff -a
sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab

Load required kernel modules:

cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
overlay
br_netfilter
EOF

modprobe overlay
modprobe br_netfilter

cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-iptables  = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.ipv4.ip_forward                 = 1
EOF

sysctl --system

Install containerd (container runtime):

apt-get update
apt-get install -y containerd
mkdir -p /etc/containerd
containerd config default | tee /etc/containerd/config.toml
sed -i 's/SystemdCgroup = false/SystemdCgroup = true/' /etc/containerd/config.toml
systemctl restart containerd

Install kubeadm, kubelet, and kubectl:

apt-get install -y apt-transport-https ca-certificates curl gpg

curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.29/deb/Release.key | \
  gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg

echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] \
  https://pkgs.k8s.io/core:/stable:/v1.29/deb/ /' | \
  tee /etc/apt/sources.list.d/kubernetes.list

apt-get update
apt-get install -y kubelet kubeadm kubectl
apt-mark hold kubelet kubeadm kubectl

Step 4 — Initialize the Control Plane

Run this only on the master node:

kubeadm init \
  --pod-network-cidr=10.244.0.0/16 \
  --apiserver-advertise-address=192.168.1.100

After successful initialization, set up kubectl access:

mkdir -p $HOME/.kube
cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
chown $(id -u):$(id -g) $HOME/.kube/config

The kubeadm init output includes a kubeadm join command with a token. Save this command — it is needed to join the worker nodes.

Step 5 — Install Flannel Network Plugin

The cluster needs a CNI (Container Network Interface) plugin before pods can communicate. Flannel is the simplest option for homelab use:

kubectl apply -f https://github.com/flannel-io/flannel/releases/latest/download/kube-flannel.yml

Wait 60 seconds, then verify the CoreDNS pods are running:

kubectl get pods -n kube-system

All pods should show Running status before proceeding.

Step 6 — Join Worker Nodes

Run the join command from Step 4 on each worker node:

kubeadm join 192.168.1.100:6443 \
  --token YOUR_TOKEN \
  --discovery-token-ca-cert-hash sha256:YOUR_HASH

If the token has expired (tokens expire after 24 hours), generate a new one on the master:

kubeadm token create --print-join-command

kubeadm init sets up your control plane in minutes — no managed service needed

Step 7 — Verify the Cluster

From the master node:

kubectl get nodes

Expected output:

NAME          STATUS   ROLES           AGE   VERSION
k8s-master    Ready    control-plane   5m    v1.29.0
k8s-worker1   Ready    <none>          3m    v1.29.0
k8s-worker2   Ready    <none>          3m    v1.29.0

All three nodes should show Ready. Deploy a test workload to confirm everything works:

kubectl create deployment nginx --image=nginx --replicas=3
kubectl get pods -o wide

Pods should distribute across both worker nodes automatically.

What to Practice on This Cluster

This setup is equivalent to what the CKA exam tests. Build these skills in your homelab:

RBAC and security:

• Create service accounts with limited permissions
• Configure role bindings and cluster role bindings
• Practice network policies to isolate namespaces

Workload management:

• Deploy applications with Deployments, DaemonSets, and StatefulSets
• Configure horizontal pod autoscaling (HPA)
• Practice rolling updates and rollbacks

Storage:

• Set up persistent volumes and persistent volume claims
• Configure dynamic storage provisioning with local-path-provisioner

Networking:

• Install Nginx ingress controller
• Configure ingress rules for multiple services
• Set up TLS termination at the ingress layer

Observability:

• Deploy Prometheus + Grafana using Helm
• Set up alerting rules
• Practice log aggregation with Loki

Pods spinning up and distributing across nodes — Kubernetes orchestration in action

Key Takeaways

• Proxmox VE is free, enterprise-grade, and runs on any x86 hardware
• A full three-node K8s cluster requires 16GB RAM minimum — 32GB recommended
• kubeadm gives you a real cluster identical to what the CKA exam tests
• Flannel is the simplest CNI for homelab — Calico or Cilium for production-like networking
• A homelab cluster costs essentially nothing and teaches more than any managed K8s service
• Proxmox snapshots let you restore a broken cluster in minutes — experiment freely

FAQ

Can I run Kubernetes on a single machine?

Yes. For minimal practice, Minikube or kind (Kubernetes in Docker) can run a single-node cluster on a laptop. However, multi-node clusters on Proxmox are more realistic and test the actual networking and scheduling behaviors that the CKA exam and production environments involve.

What is the minimum hardware for a Kubernetes homelab?

A machine with 4 CPU cores and 16GB RAM can run a functional three-node cluster. With 8 cores and 32GB RAM the experience is noticeably smoother. A secondhand mini PC or workstation in the $100–200 range typically meets these specifications.

Is Proxmox free to use?

Yes. Proxmox VE is free and open-source under AGPL license. There is a paid enterprise subscription that includes access to the enterprise repository and support, but the community edition is fully functional and has no feature restrictions.

How is a homelab K8s cluster different from EKS or GKE?

Managed K8s services handle the control plane, node upgrades, and integrations with cloud services (load balancers, storage, IAM). A self-managed cluster requires you to handle these yourself — which is exactly what makes it a better learning environment. You learn what managed services are hiding.

Can I use this setup to practice for the CKA exam?

Yes. The CKA exam uses real kubeadm-based clusters, not managed services. A Proxmox homelab built with kubeadm is the closest possible practice environment to the actual exam. Practice the official CKA curriculum tasks on this cluster.

Conclusion

A Kubernetes homelab on Proxmox is the most cost-effective way to build genuine K8s skills. Cloud-managed services are convenient for production — but for learning the internals, you need a cluster where you control everything.

Build the cluster. Break things. Fix them. The hands-on experience from managing a self-hosted cluster is worth more than any number of video courses.

Read next: AWS Region Outage: Complete Emergency Migration Guide →

Need help setting up a production Kubernetes cluster on AWS EKS? View our Kubernetes setup service →