Home mini PC with a monitor showing a diagram of virtual machines and clusters

A single second-hand mini PC running Proxmox VE is enough to host two Kubernetes clusters, a secrets vault, an NFS server and a handful of home network services, all described as code in a public repository. That is the idea behind Maxym Gryn’s homelab project, which splits the work between Terraform, Ansible and ArgoCD and documents both what works and what broke. The stated goal is that if the disk dies, the whole environment can be rebuilt from Git plus a short list of things Git does not hold.

The key points of this Proxmox and Kubernetes homelab in 30 seconds

  • A Dell OptiPlex 3090 Micro with 32 GB of RAM runs Proxmox and two clusters: kubeadm for development and Talos Linux for production.
  • Terraform creates the VMs and LXC containers, Ansible configures them and ArgoCD deploys applications from the main branch.
  • Secrets live in HashiCorp Vault, and TLS certificates come from Let’s Encrypt through DNS-01 validation.
  • The author admits that one host and backups on the same SSD do not protect against a dead disk.

The author wanted to host a few web projects without the cloud and to try an on-premises setup. He ruled out a used rack server because of noise, power and space, and bought a second-hand Dell OptiPlex 3090 Micro instead: an Intel Core i5-10500T, 32 GB of DDR4 and a 1 TB NVMe SSD, idling at around 8 to 12 W by his measurements. The hard question, he writes, was not the hardware but how to manage what runs on it without ending up with a machine full of manual changes nobody could reproduce.

What runs on one Proxmox host

The Proxmox host, with a single SSD, is split into three groups of machines, each with its own Terraform root:

  • Development: a kubeadm Kubernetes cluster (one control-plane node and one worker) plus a VM where the author runs Claude Code.
  • Production: a Talos Linux cluster, the immutable Kubernetes-only operating system, with one control-plane node and two workers.
  • Shared: a HashiCorp Vault VM, an NFS server and LXC containers for the home network: Pi-hole (DNS and ad blocking), Traefik (reverse proxy), Glance (dashboard), Gatus (uptime checks with Telegram alerts) and Orangutan (device discovery).

The author jokes that development and production are completely separate, except for the machine, the storage, the power supply and everything else that can ruin an evening. The split still lets him experiment in one cluster without touching the other, but it does not remove the shared host as a single point of failure.

Persistent storage comes from the NFS server, which exports one share for development (the default StorageClass) and another that only the production workers can mount. Every machine has a static address outside the router’s DHCP pool.

Three tools for three different jobs

Automation is split into layers. Terraform creates the VMs and LXC containers on Proxmox. Ansible configures what runs inside them: the kubeadm cluster, the containerd runtime, NFS, Vault and the LAN services. ArgoCD delivers Kubernetes applications from Git. The author’s reasoning is that provisioning, operating system configuration and application delivery are different problems with different failure modes, and mixing them makes debugging harder.

The Kubernetes layer has one strict rule: ArgoCD syncs main on GitHub, not the local working copy. A commit is not a deploy, a pushed branch is not a deploy and an open pull request is not a deploy. Only merging to main deploys, so the author opens the PR, reviews it and merges it himself when he is ready to watch the rollout.

The Talos production cluster doubles as the GitOps hub. Its ArgoCD, bootstrapped by an Ansible playbook, uses a root application (the app-of-apps pattern) and an ApplicationSet that generates production applications from a per-app config file, and it also manages deployments into the development cluster. HTTP ingress runs on ingress-nginx as a DaemonSet on host ports 80 and 443. There is a real workload behind it all: the author’s job board application with PostgreSQL, running in production on Talos with development as staging. Its source code sits in a private repository; the public one holds only the deployment configuration and the published image.

Running two clusters with different tooling is deliberate. With kubeadm, configured by Ansible alongside containerd, and Talos, managed through its own Terraform module, the lab offers two Kubernetes operating models rather than two copies of the same one. Readers who want to try something similar can also look at how a reproducible Kubernetes lab was built with Proxmox and Terraform.

Secrets, certificates and monitoring as part of the platform

No secret is committed in plain text. Manifests carry placeholders such as <path:kv-prod/data/…#FIELD>, and ArgoCD Vault Plugin swaps them for real values at sync time. Development and production read separate Vault paths.

HTTPS certificates follow two paths. Kubernetes services use cert-manager, while LAN services behind Traefik rely on Traefik’s own certificate automation. Both request certificates from Let’s Encrypt using DNS-01 validation through the Cloudflare API, but with separate tokens so either can be revoked without affecting the other. Public names are DNS-only Cloudflare records pointing at private addresses, so any device on the LAN can resolve them without a hosts file entry. The repository warns that some routers drop such answers as DNS rebinding protection.

Monitoring lives in production with kube-prometheus-stack (Prometheus, Grafana and Alertmanager). Development runs a Prometheus agent that forwards metrics to the hub, and an exporter collects Proxmox metrics too. Alerts go to Telegram. Grafana dashboards are written in Jsonnet and rendered to JSON committed to the repository, so monitoring does not become another set of manual changes to reconstruct later.

What broke and the rules it left behind

For most administrators, the most useful part of the project is the failures, which the author has turned into repository instructions and architecture decision records (ADRs):

  • Renaming a Terraform module destroyed the dev cluster. Terraform tracks resources by address, so a new name reads as delete the old, create the new. A one-line rename rebuilt all three dev VMs from a blank template and the database had to be restored. Every rename now needs a moved block.
  • A healthy app nobody could reach. Grafana showed as Healthy in ArgoCD for hours while being unreachable, because there was no ingress controller. Synced only means Kubernetes accepted the manifests, not that anything serves traffic. The author now checks the service itself with curl and kubectl get pods.
  • A sealed Vault fails quietly. After a reboot, Vault comes back sealed, the plugin renders nothing, apps go Unknown on sync status and ArgoCD health still says Healthy. The first thing he checks when an app stops syncing is vault status.
  • Ordering matters. The first Vault plugin setup mounted a ConfigMap that did not exist yet and left the ArgoCD repo server stuck in Init for six hours. The fix was to create dependencies before the Helm deploy runs.

Every change is validated before it reaches the lab. Local pre-commit hooks check file hygiene, YAML, private keys and secrets with gitleaks, shell scripts with shellcheck, Ansible with ansible-lint at the production profile, and Terraform and Jsonnet formatting. In GitHub Actions, seven parallel jobs repeat those checks and add Terraform validation and tests, kustomize rendering with kubeconform validation of the manifests, ApplicationSet expansion and a check that dashboards match their sources. CI is read-only by design: it never touches Proxmox, the clusters or any secret. Dependencies are updated with Renovate.

Git is not the whole recovery plan

One of the most important files in the project is docs/rebuild.md, the guide for recovering after a disk replacement or total loss. What matters is that it lists what the repository does not contain: Proxmox itself, the ansible-vault encrypted secret.yaml, the gitignored *.tfvars files and the Talos certificates held in Terraform state. The author’s lesson is that having configuration in Git is not the same as having everything needed to recover.

He is also upfront about the limits. One physical host means no failover, and backups sit on the same SSD they protect: they cover a bad upgrade or a deleted secret, not a dead disk. That, he says, makes everything he describes a claim until it has been tested from bare metal. His next step is to ship backups off the machine, wipe Proxmox and rebuild following only what is written down, fixing the guide wherever he has to improvise.

His four takeaways apply well beyond a homelab: write the decision record after the first thing that breaks, check the service itself rather than a tool’s status page, list what Git does not hold before you need it, and keep CI away from production. The common thread, in his words, is the gap between configured and working, which was behind almost everything that went wrong.

Frequently asked questions

What hardware does this homelab use?

A used Dell OptiPlex 3090 Micro with an Intel Core i5-10500T, 32 GB of DDR4 and a 1 TB NVMe SSD, which the author says idles at 8 to 12 W.

Why run two different Kubernetes clusters?

To have two operating models: kubeadm configured with Ansible for development and Talos Linux managed with Terraform for production, rather than two identical copies.

How are secrets handled?

With HashiCorp Vault. Manifests contain placeholders, and ArgoCD Vault Plugin fills in the real values at sync time, with separate paths for development and production.

Is having the infrastructure in Git enough to recover it?

No. The project keeps a rebuild guide that lists what Git does not hold, such as passwords, Terraform variables and certificates, and the author admits that backups on the same disk do not cover an SSD failure.

Sources:

Scroll to Top