Zademy

Hetzner Cloud + K3s: Production Kubernetes Without the Hyperscaler Price Tag

DevOps
Kubernetes; K3s; Hetzner
words words

Whenever I look at ways to run Kubernetes, I end up asking two questions: what will it actually cost, and who gets out of bed when something breaks? Providers put the first answer in large type. The second is usually buried in documentation, limits, and fine print.

That is why the combination of Hetzner Cloud and K3s caught my attention. Not because it is some secret recipe for cheap infrastructure. It lets me build a fairly conventional cluster on resources whose cost is easier to anticipate than it can be with a hyperscaler.

The trade is conventional too. Hetzner provides servers, networking, and the other infrastructure pieces. K3s provides Kubernetes. The operator provides everything else.

The appeal is not just a lower bill

I do not want to pin a fixed price table to this article. Those age badly. Rates, included traffic, and instance types change. Comparing one virtual machine is not especially useful either when the alternative is a managed service that bills the control plane, load balancers, storage, egress, and support in different ways.

What matters more to me is being able to understand the invoice without solving a puzzle every month. I choose the servers, volumes, load balancers, and traffic, then I can estimate the total with reasonable confidence. For small projects, serious labs, or teams already comfortable operating Linux, that predictability carries real weight.

K3s helps because it is still Kubernetes. I can use kubectl, Helm, manifests, operators, and the usual tooling. It does not force me to invent another deployment workflow or lock workloads behind a provider-specific API. The distribution is smaller, but the daily conversation still happens in standard Kubernetes terms.

That compatibility is what made the option genuinely interesting to me. Saving some money is useful. Keeping portable tools and knowledge is worth more.

The pieces fit, but nobody manages the cluster

Hetzner maintains useful official integrations. The hcloud cloud-controller-manager connects Kubernetes to Hetzner infrastructure and, among other things, lets the cluster work with nodes and load balancers. When I checked the project on August 28, 2026, the current release was v1.34.0. One detail matters: versions v1.30.0 and earlier have an issue involving a deprecated Kubernetes API. This is not a component I would install once and then forget.

The official CSI driver brings Hetzner volumes into Kubernetes. The version I checked on the same date was v2.22.0. It makes requesting persistent storage through a PersistentVolumeClaim straightforward, with one constraint that belongs in the design discussion: these volumes are ReadWriteOnce. They work for plenty of stateful workloads, but they are not shared storage that several nodes can mount at the same time.

So far, so good. What Hetzner does not offer is an official managed K3s control plane. There is no equivalent of clicking “create cluster” and leaving etcd, upgrades, and recovery to a provider team. This is self-managed Kubernetes running on Hetzner Cloud.

Community projects can reduce the setup work. kube-hetzner models the cluster in Terraform and fits well if I already treat infrastructure as code. hetzner-k3s takes a more direct route focused on deploying K3s. Both look like sensible starting points.

I would still read their release notes, supported versions, defaults, and open issues before putting anything important on top. Automation removes repetitive work. It does not transfer responsibility.

The work that does not go away

Networking comes first. I have to decide what stays on the private network, which services are public, and how Hetzner firewalls interact with policies inside the cluster. Opening ports until everything works is quick. Remembering six months later why they are still open is not.

Then there is high availability. If the cluster matters, a single control-plane server is a bet, not an architecture. Nodes need to be distributed, unnecessary dependencies on one machine need to go, and failure behavior needs to be tested. Drawing three nodes in a diagram does not prove recovery works.

Backups are my problem too. That means application data and the state required to rebuild the cluster. A snapshot is not a complete strategy if I have never restored it. I would rather have a boring, repeatable recovery drill than a directory full of backups nobody has opened.

Upgrades are another part of the bill. K3s, Kubernetes, the CCM, the CSI driver, the operating system, and every extra component move at different speeds. Someone has to read release notes, test compatibility, respect upgrade order, and keep an exit route when something breaks. The deprecated API issue in older CCM releases is a useful reminder that “it works today” is not enough.

I also need observability, certificate rotation, replaceable nodes, secret protection, and a recovery procedure that does not live in one person's memory. A lightweight distribution makes none of that disappear.

Where I land for now

Hetzner with K3s makes sense to me when I want predictable costs, understand the workloads, and accept that I am operating the platform. I keep the normal Kubernetes ecosystem, get official integrations, and can use community projects instead of starting from an empty directory.

I would not choose it just because a shallow comparison shows cheaper servers. If the team has no time to test backups, plan upgrades, and respond to incidents, the apparent savings can turn into expensive hours and unpleasant nights. In that case, managed Kubernetes is not wasted money. It is paying someone to own operational responsibility.

The useful question is not whether Hetzner plus K3s replaces a hyperscaler. It is whether I want enough control to justify everything I will have to look after. When the answer is yes, this combination is compelling. When it is no, I would rather admit that before an outage does it for me.

Resources