Hostinger

Hostinger sells KVM VPS instances with a public API and an official Terraform provider. SHC runs on it as a plain compute substrate: public-IP Debian boxes, provisioned by terraform/modules/shc/hostinger and bootstrapped by terraform-provider-shc over SSH.

It is the smallest substrate SHC supports, and the page below is mostly a list of things other clouds have and this one does not. Read the cost section first — it is the reason this module ships UNVERIFIED-LIVE, which no other cloud module in the tree does.

One-line summary. Hostinger is a substrate-only, single-box-shaped cloud: no private network, no load balancer, no block volumes, no cloud firewall in terraform, no tags. Supported topologies are one node, or many nodes over the nebula WAN overlay. DNS always comes from another provider.

This is the headline, not a footnote.

Hostinger does not rent VPS capacity by the hour. Every node is a purchased subscription whose term is encoded in the plan SKU, the shortest term sold is one month, and tofu destroy cancels the subscription rather than stopping a meter. There is no proration. A ten-minute test cluster costs a full month per node.

(USD, read live from the catalog on 2026-07-31; first-month prices are promotional. -usd-1y and -usd-2y variants buy longer terms at a lower monthly rate. Read the current numbers yourself — see below.)

curl -s -H "Authorization: Bearer $HOSTINGER_API_TOKEN" \
  'https://developers.hostinger.com/api/billing/v1/catalog?category=VPS' |
  jq -r '.[] | .id as $p | .prices[] | [$p, .id, .price, .first_period_price] | @tsv'

Prices are in cents. Two consequences are wired into the code rather than left to discipline:

• the module refuses to plan unless accept_monthly_billing = true;
• the test lane refuses to run unless SHC_TEST_HOSTINGER_ACCEPT_BILLING=1, and its SHC_TEST_NODE_COUNT defaults to 1, not 3.

A leftover node here does not leak pennies per hour — it renews at a full month. That is why tests/clouds/hostinger/scripts/destroy.sh finishes by asking the API whether any VPS still carries the lane prefix, and why the lane tears down even on a failed run.

LIVE-PROVEN 2026-07-31. A 1-node cell and a 2-node nebula-overlay cell both ran SCENARIO PASS on a real account (fra, kvm1): purchase, post-install prep, shc init --nebula, cloudflare DNS + Let’s Encrypt cert, shc node join across two VPSes, mesh enrollment and bidirectional mesh-IP pings — then an API-verified teardown with the subscriptions cancelled. The module README’s banner carries the full findings list (provider bugs, WAF gotcha, FQDN hostname rule, recreate password rule).

Exactly two, and the second one is the overlay.

One VPS, one public IP, ingress and the daemon on the same box. Nothing to mesh. This is the shape the substrate is actually good at.

There is no private network to put a cluster plane on, so a second node can only reach the first over the public internet. The module therefore stages the nebula binaries automatically as soon as more than one node is declared, and the cluster plane rides the nebula WAN overlay — the same shape the cross-cloud mesh lane and the BYO / home-lab lane use.

node_groups = {
  nodes = { count = 2, plan = "hostingercom-vps-kvm1-usd-1m", runtime = "compose" }
}

bootstrap = {
  # ...
  nebula = true
}

topology = { kind = "wan" }

topology.kind = "lb" is a hard validation error — there is no managed load balancer to point it at.

Be explicit about this before choosing Hostinger for anything real.

A multi-node Hostinger cluster has no single ingress address. System Traefik runs where the platform places it, DNS points at node IPs, and there is nothing in front to fail over:

• a DNS record naming one node is a single point of failure for that host;
• round-robin A records spread load but do not health-check, so a dead node keeps taking a share of traffic until DNS changes;
• a request landing on node B for a service running on node A is not transparently proxied. Keep publicly-fronted services on the node DNS points at, or accept the gap.

If you need ingress HA, use an LB-bearing cloud (hetzner, aws, azure, digitalocean).

Each VPS has one fixed disk. It cannot be detached, moved to another node, or grown independently of the plan. There is no SHC volume provider for Hostinger, so apps ride node-local docker volumes and app data lives and dies with its node — the same posture as exoscale and openstack today. Back up accordingly; a node recreate on this substrate is also a fresh purchase.

Hostinger has a VPS firewall product (/api/vps/v1/firewall), but the terraform provider exposes no resource for it. Every port a container publishes is reachable from the internet. The module refuses firewall.inter_node = "plane" / "none" rather than pretending to honor them. Compensating controls, in order:

1. run the plane over the nebula overlay (topology.kind = "wan") so cross-node traffic is encrypted end to end;
2. bind app ports to the overlay or loopback and front them with system Traefik;
3. configure a host firewall deliberately — noting the post-install script disables the image’s ufw, because a half-configured host firewall silently eats the cluster plane (ICMP passes, so ping lies, while the plane’s TCP/UDP ports are dropped and joins time out X500023JNFAIL).

Reopen this the day the provider grows a firewall resource.

The VPS API carries no metadata field whatsoever. A node cannot be attributed to a cluster from the cloud side except through its hostname, which is why the module writes the sanitized SHC node name there and why the lane’s teardown check and reaper both match on a hostname prefix.

Mint one in the Hostinger panel (VPS → API tokens) and export it:

export HOSTINGER_API_TOKEN=...

It backs the hostinger terraform provider only — there is no SHC hostinger connection type, because there is no proxy or volume backend to connect.

Two things to check before your first apply, both of which will otherwise fail at purchase time:

# 1. A payment method must exist. An empty list means nothing can be bought.
curl -s -H "Authorization: Bearer $HOSTINGER_API_TOKEN" \
  https://developers.hostinger.com/api/billing/v1/payment-methods

# 2. The account must not be VIRGIN. On an account owning zero VPSes the
#    post-install-script endpoints answer 403 "[VPS:2000] Unauthorized"
#    (an ACCOUNT-STATE gate, not a token scope — hPanel tokens have no
#    scopes; live-verified 2026-07-31: the 403 flips to 200 the moment
#    the first VPS purchase completes). Terraform creates the script
#    BEFORE the first VPS, so a from-empty apply on a virgin account
#    fails (safely, before money moves). Buy the account's first VPS
#    once — panel or API — and every later from-empty apply works.
curl -s -o /dev/null -w '%{http_code}\n' \
  -H "Authorization: Bearer $HOSTINGER_API_TOKEN" \
  https://developers.hostinger.com/api/vps/v1/post-install-scripts

Hostinger DNS is never wired. Point SHC at a zone you already own — a Cloudflare Zone:DNS:Edit token on the parent zone is the default and the recommended path:

export SHC_TEST_DOMAIN=example.com
export SHC_TEST_CLOUDFLARE_TOKEN=cf-xxxxxxxx

A Hetzner-hosted parent zone works too (SHC_TEST_DNS_PROVIDER=hetzner).

provider "hostinger" {} # token from HOSTINGER_API_TOKEN

module "shc" {
  source = "../../modules/shc/hostinger"

  # Every node is a >= 1-month, non-refundable subscription.
  accept_monthly_billing = true

  cluster_name   = "demo"
  data_center    = "fra"
  ssh_public_key = file("~/.ssh/id_ed25519.pub")
  ssh            = { user = "admin", private_key_path = "~/.ssh/id_ed25519" }

  node_groups = {
    nodes = { count = 1, plan = "hostingercom-vps-kvm1-usd-1m", runtime = "compose" }
  }

  bootstrap = {
    package        = { deb_url = "https://.../shc_..._linux_amd64.deb" }
    vault_password = var.vault_pw
    host           = "cloud.example.com"
  }

  topology = { kind = "lan" }
}

Then wire DNS + ACME as root shc_* resources (a cloudflare shc_connection plus an shc_config), exactly as tests/clouds/hostinger/terraform/main.tf does. There is no cloud connection to add alongside it.

HOSTINGER_API_TOKEN=... CLOUDFLARE_API_TOKEN=... SHC_TEST_DOMAIN=example.com \
  SHC_TEST_HOSTINGER_ACCEPT_BILLING=1 \
  make test/hostinger          # buys one month; provisions, verifies, tears down

make test/hostinger/clean      # teardown + an API check that no VPS survives

SHC_TEST_NODE_COUNT=2 runs the overlay cell and buys a second month. Full env contract in tests/clouds/hostinger/README.md.

If a state file is ever lost, the stateless path still lists strays from the prefix alone:

tests/clouds/lib/reap-run.sh --cloud hostinger --prefix shc-hostinger

Verified against hostinger/hostinger 0.1.22 on 2026-07-31.

Data sources: hostinger_vps_data_centers, hostinger_vps_plans, hostinger_vps_templates. There is no volume, network, firewall or load balancer resource anywhere in the provider.

• Module: terraform/modules/shc/hostinger — the deltas table, the sanitizer rules, and the first-apply checklist
• Lane: tests/clouds/hostinger
• The overlay shape this substrate depends on: tests/clouds/mesh
• Clouds index — the shared env-var contract every lane honors