Originally published on kuryzhev.cloud
A three-person team runs a staging cluster, a production cluster and a handful of internal tools on AWS. The monthly bill is dominated by things nobody chose deliberately: control plane fees, NAT gateways, load balancers and cross-AZ traffic. Someone proposes a Hetzner OpenTofu cluster as a replacement, and the question becomes whether the savings justify the trade-offs.
The timing is reasonable. OpenTofu 1.13 is the current release cycle (September 2026). Kubernetes 1.37, released independently in August 2026, is the current Kubernetes cycle. The tooling for small self-managed clusters is mature enough that the main question is no longer "can it work" but "who carries the pager for the control plane".
Short answer: run it on Hetzner with OpenTofu if three things are true:
- Your workload is stateless or can tolerate downtime.
- Your compliance needs are modest.
- Someone on the team is willing to own Kubernetes upgrades and datastore backups.
Stay on EKS and cut costs inside AWS instead if you depend on IAM-integrated services, managed databases, or a contractual SLA on the control plane.
When this choice matters
The decision is rarely about raw compute price. It matters when your infrastructure bill is mostly "plumbing" rather than application load: a small cluster of a few nodes with a load balancer, some persistent volumes and moderate egress.
At that size, fixed per-hour charges on AWS (control plane, NAT, load balancers) are a large share of the total. Hetzner bills mainly for servers, volumes and load balancers, with a traffic allowance included per server. Check both pricing pages before trusting any comparison, including this one; prices and allowances change.
It matters less when you already use many AWS-native services (RDS, SQS, IAM-based workload identity, KMS). Moving the cluster alone then adds cross-provider latency and egress, and you lose the identity model that made those integrations easy.
Also consider the people cost. Hetzner Cloud does not currently offer a managed Kubernetes product (check their current offering before deciding), so the control plane is yours. That is a real operational commitment, not a footnote.
Option A: a Hetzner OpenTofu cluster
The pattern is simple:
- The
hetznercloud/hcloudprovider creates a private network, firewall, servers and a load balancer. - Cloud-init or a bootstrap tool installs a lightweight distribution such as k3s, or an immutable one such as Talos.
- The Hetzner cloud controller manager and CSI driver then handle load balancers and volumes from inside the cluster.
See the OpenTofu documentation for the language and provider mechanics.
A minimal skeleton you can adapt:
# main.tf terraform { required_version = ">= 1.13" required_providers { hcloud = { source = "hetznercloud/hcloud" version = "~> 1.0" # pin to the current minor from the registry } } } variable "hcloud_token" { type = string sensitive = true } variable "server_type" { default = "cx23" } # verify: hcloud server-type list variable "image" { default = "ubuntu-26.04" } # verify: hcloud image list --type system provider "hcloud" { token = var.hcloud_token } resource "hcloud_network" "k8s" { name = "k8s" ip_range = "10.0.0.0/16" } resource "hcloud_network_subnet" "nodes" { network_id = hcloud_network.k8s.id type = "cloud" network_zone = "eu-central" ip_range = "10.0.1.0/24" } # Hetzner firewalls filter public interfaces only; private network traffic # between nodes is not affected. Unlisted inbound ports (including SSH) are blocked. resource "hcloud_firewall" "nodes" { name = "k8s-nodes" rule { # API server: restrict to your admin IP, never 0.0.0.0/0 direction = "in" protocol = "tcp" port = "6443" source_ips = ["203.0.113.10/32"] } } resource "hcloud_server" "node" { count = 3 name = "k8s-${count.index}" server_type = var.server_type image = var.image location = "fsn1" firewall_ids = [hcloud_firewall.nodes.id] network { network_id = hcloud_network.k8s.id } depends_on = [hcloud_network_subnet.nodes] } Pros:
- Low and predictable fixed cost, with no control plane fee.
- Simple networking.
- The whole stack fits in one repository.
- OpenTofu's built-in state encryption protects the state file, which will contain tokens and kubeconfig material.
Cons:
- You run the cluster datastore (etcd, or SQLite for single-server k3s), upgrades and certificates.
- No managed SLA.
- Fewer regions: mostly EU, plus a few in the US and Asia.
- No IAM-style workload identity.
- Storage is block volumes, not a managed multi-AZ service.
Watch out: the default state backend is local. Decide on remote state with encryption before the first apply, not after.
Option B: AWS EKS with managed services
EKS gives you a managed control plane and workload identity through EKS Pod Identity or IAM roles for service accounts. It integrates tightly with ALB, EBS, RDS and CloudWatch. Control plane upgrades are a managed operation, and the ecosystem of add-ons is large. The EKS documentation covers the supported versions and upgrade path.
Pros:
- Lower operational burden for the control plane.
- Mature identity, audit and compliance tooling.
- Managed databases and queues are one network hop away.
- Many regions and availability zones.
- Procurement and security reviews are often easier when reviewers already know AWS.
Cons:
- Fixed costs add up for small clusters. The control plane is billed per cluster-hour, and NAT gateways and load balancers add hourly and per-GB charges.
- Cross-AZ traffic is billed.
- Cost control becomes its own workstream, and it is easy to leave idle resources in several accounts.
- Lock-in is real as soon as you adopt IAM-based workload identity and AWS-specific load balancer annotations.
Watch out: do not base the comparison on list prices alone. Savings Plans, Spot nodes and Graviton instances change the AWS side materially, so price a tuned EKS setup, not a default one.
Decision matrix
| Factor | Hetzner + OpenTofu | AWS EKS |
|---|---|---|
| Fixed monthly cost at 3 nodes | Low | Higher (control plane, NAT, LB) |
| Control plane ownership | You | AWS |
| Managed DB / queues | Self-host or third party | Native |
| Workload identity | Tokens, external secrets | EKS Pod Identity or IRSA |
| Regions / compliance breadth | Limited | Broad |
| Egress-heavy workloads | Included allowance, then per-TB | Per-GB charges |
| Team size needed | One person who knows Kubernetes internals | Less, but cost discipline needed |
| Exit cost | Low (plain Kubernetes) | Medium to high |
Read the table by your constraints, not by row count. A single hard requirement, such as a regulated workload tied to a specific AWS service, outweighs several soft savings.
Evidence-based recommendation
Choose the Hetzner path when all four of these conditions hold:
- The workload is portable Kubernetes without deep AWS service coupling.
- A brief control plane outage is acceptable.
- A named person owns upgrades.
- Your data-residency needs fit the available locations.
Choose EKS when any of those fail.
A middle route is also possible: keep data stores and identity in AWS and move stateless or batch workloads to Hetzner. Only do this if the cross-provider latency and the AWS egress charges are measured and acceptable.
Before committing, run the plan and an actual cost test. Encrypt state and saved plans first. The passphrase goes in an environment variable, not in the repository:
export TF_ENCRYPTION=' key_provider "pbkdf2" "main" { passphrase = "REPLACE-WITH-A-LONG-SECRET" } method "aes_gcm" "default" { keys = key_provider.pbkdf2.main } state { method = method.aes_gcm.default } plan { method = method.aes_gcm.default } ' export TF_VAR_hcloud_token="REPLACE-WITH-PROJECT-TOKEN" # read-write project token export HCLOUD_TOKEN="$TF_VAR_hcloud_token" # used by the hcloud CLI tofu init tofu plan -out=plan.tfplan # review: expect 1 network, 1 subnet, 1 firewall, 3 servers tofu apply plan.tfplan hcloud server list # verify: three servers in "running" state # after installing k3s or Talos and fetching the kubeconfig: kubectl get nodes -o wide # verify: all nodes Ready; 10.0.1.x internal IPs only if # the distribution/CCM is configured to use the private network Open terraform.tfstate directly in an editor. With encryption enabled, it should not be readable JSON. Note that tofu show decrypts with your key, so its output is readable by design. Check the exact encryption syntax against the OpenTofu documentation for your installed version before relying on it.
Two more cautions:
- Ingress: do not copy older guides that install ingress-nginx. It was retired in March 2026, so use a Gateway API implementation or another maintained controller instead.
- Backups: schedule datastore snapshots (etcd, or the k3s datastore) and restore drills from day one. A cluster you cannot rebuild from OpenTofu plus a backup is just a cheaper liability.
For related tooling choices, browse more infrastructure posts on kuryzhev.cloud.
The honest summary: a Hetzner OpenTofu cluster trades money for responsibility. If that trade suits your team, the savings are real. If it does not, the cheapest cluster is the one nobody has to be woken up for.

