- Docs
- Concepts
Concepts
How Syself Autopilot works and why it is worth owning
Foundations
- Architecture Syself builds the whole cluster as one hash-pinned unit and locks it to a release before any node boots, so the boundaries between OS, topology, and cluster components are Syself's to manage, not yours.
- Management and Workload Clusters Your workload cluster is a complete Kubernetes cluster on your own Hetzner servers; the management cluster is where Syself runs the automation that builds and looks after it.
- Inside a Workload Cluster What a running workload cluster is made of: what sits on a control-plane node, what sits on a worker, how KubeGate fronts the API server, and how the pieces connect over the public internet.
- Cluster Stacks One version number pins the node OS, the cluster topology, and the cluster components together, so every cluster runs a combination Syself tested as a whole.
- Declarative Cluster Management Your whole cluster is one Kubernetes object, and Syself's controllers keep the running cluster matching it continuously, not just at apply time.
The operations model
- The node lifecycle: replacement instead of patching A Syself node is built immutable before it boots, never patched while it runs, and replaced with a fresh identical node when it needs to change.
- Fast, Reliable Provisioning Every hard part of building a Syself node happens in a throwaway rescue system before the node boots, so a node either comes up correct or never joins.
- Self-Healing and Node Replacement How Syself Autopilot detects and repairs node failures with three recovery layers, and why a hard safety gate stops it from replacing your whole fleet.
- Cluster Upgrades How Syself Autopilot moves a cluster to a new tested version by replacing nodes one at a time, with the control plane available throughout.
- Backup and Disaster Recovery Syself heals your infrastructure but does not back up your data. Know what state exists in a cluster, what survives a node dying, and how each piece comes back.
- The observability model Every Syself Autopilot cluster runs live monitoring (metrics-server, Hubble, a node health daemon, audit logs) and you bring the storage, so the metrics, logs, and audit trail stay on storage you own.
Platform internals
- Syself Linux The node OS on every server in your cluster is read-only, around 350 MB, immutable, verified by the kernel on every disk read, and replaced instead of patched when it must change.
- Platform Components: KubeGate, syself-agent, and the Tunnel The Syself-built pieces that let a Kubernetes node run safely on the public internet: KubeGate in front of a loopback-only API server, the one syself-agent binary, and a reverse mTLS tunnel that nodes dial outward.
- Networking and Cilium How one eBPF layer (Cilium) does pod networking, service load balancing, the host firewall, and network policy in every cluster, and where L7 policy still falls short.
- The Storage Model Syself Autopilot ships one storage backend, network-attached Hetzner Cloud volumes; local disks through TopoLVM are fast but pinned to one machine, so a database on local disk cannot move off that machine.
- Minimal Provider Dependency Syself Autopilot takes servers and load balancers from Hetzner and nothing else, and never builds a security boundary on the Hetzner private network.
Own it, your way
- What You Own, What Syself Manages Hetzner runs the hardware, Syself runs the platform and ships the compliance evidence, and you own your workloads and your audit.
- The Economics of Owning vs Renting Owning your servers costs far less than renting equivalent cloud compute, because renting adds a per-vCPU premium, a per-gigabyte egress bill, and a per-cluster control-plane fee that owning avoids.
- The security model Every connection into a Syself Autopilot node authenticates on its own, so a node runs safely on the public internet with no private network. You still configure SSH access and pod-to-pod segmentation.
- Sovereignty and Data Residency Why an EU region alone does not make you sovereign, and how Syself Autopilot closes the gap with clusters in your own Hetzner account, a dedicated control plane per cluster, and keys you generate yourself.
- The Kubernetes Layer for Sovereign Cloud Stack (SCS) Syself builds the Kubernetes-as-a-Service layer for the Sovereign Cloud Stack, and Syself Autopilot runs on that same open standard, so you can prove your cluster's conformance yourself.
- Run Your Own Services Syself runs the cluster; you run the databases, queues, and caches you used to rent, on standard open-source operators, behind the plain Kubernetes API.
- Run It Yourself, or With Help Every service on Syself Autopilot is standard Kubernetes objects in your own cluster, so you can run it yourself, have Syself operate it, or move between the two per service without migrating anything.