- Docs
- Workloads
Workloads
Run production workloads
- Deploy your first app Deploy a sample application and expose it with a Hetzner Load Balancer using kubectl. See the external IP appear and access your app from the internet.
- Production readiness checklist What to check before a workload or component runs in production, from replicas and pod security to backups and GitOps, with a link to the page that covers each practice in depth.
- Survive node drains The one page that wires every setting a real Deployment needs to survive a node drain, then narrates a single drain to show each one earning its place.
- Configure health probes The probe mistakes that drop traffic on a platform that drains and replaces nodes, and how readiness, liveness, and startup probes avoid them.
- Set resource requests and limits Why the right default on this platform is a memory limit equal to the request, no CPU limit, and Burstable QoS.
- Add a PodDisruptionBudget Cap how many pods can be down during a drain so an upgrade or repair never takes your whole app offline, and read the two symptoms that mean the budget is wrong.
- Handle graceful shutdown Finish in-flight requests when a node is replaced instead of dropping connections, by closing the endpoint-deregistration race with preStop and SIGTERM handling.
- Set namespace defaults with LimitRange and ResourceQuota Give each namespace default resources and a hard ceiling so one tenant can never starve another.
Placement and scheduling
- Steer workload placement A decision table that routes you to the right placement control, plus the default node and zone spread that already runs before you set anything.
- Node affinity and selectors in practice Use nodeSelector or node affinity to steer pods onto the right pool, matching the exact labels you set.
- Set affinity and anti-affinity Require or prefer certain nodes, and co-locate or separate pods from each other, when a plain node selector is not enough.
- Spread pods with topology constraints Keep replicas on separate nodes and zones so a single node replacement takes at most one of them.
- Taints and tolerations Add taints to node pools through the Cluster topology to control which pods can schedule on them.
Availability
- Keep workloads available How a node replacement moves your pods, the conditions every workload needs to survive it, and where to go next for your workload type.
- Keep stateless workloads available Apply the availability conditions to a stateless Deployment, size the PodDisruptionBudget and spread, and add the graceful shutdown that finishes in-flight requests through a node replacement.
- Keep ingress and load balancers available Keep your ingress controller and Hetzner load balancer serving through a node replacement with spread ingress replicas, a PodDisruptionBudget, and the right externalTrafficPolicy.
- Keep databases available How a database behaves when its node is replaced, why a single instance has a short gap, and how a replicated database with failover stays available.
Scaling
- Scale out with the Horizontal Pod Autoscaler Autoscale replicas on CPU, memory, or custom metrics, and keep minReplicas high enough to survive a node roll.
- Right-size with the Vertical Pod Autoscaler Let the VPA recommend or apply the CPU and memory requests a workload actually needs instead of guessing.
- Scale a workload to zero On your own hardware, scaling to zero is the difference between paying for a node all night and letting the cluster drop it.
Stateful workloads
- Run a StatefulSet with storage Nodes get replaced routinely, so the storage class you choose is what decides whether your StatefulSet's data survives. Pick between local NVMe, Hetzner volumes, and shared JuiceFS.
- Keep stateful pods safe across node replacement How to place stateful replicas so a Syself Autopilot node replacement rebuilds one member at a time and never costs you quorum or local data.
- Run databases on the cluster Own your Postgres instead of renting a managed one: the honest tradeoffs, why you want an operator, and where every detailed recipe lives.
Batch and jobs
- Run a Job Run a task that runs to completion on Syself Autopilot, and design it to survive node drains, run in the right runtime, land on the right node type, and scale on demand.
- Run a CronJob Schedule recurring work on a cron expression, and let idle nodes disappear between runs.
- Control retries and clean up finished jobs Finished Jobs quietly bloat etcd and slow the API server. Set a TTL so they clean themselves up, and bound retries so a failing Job cannot loop forever.
Specialized workloads
- Run GPU workloads Schedule a pod onto an NVIDIA GPU node with no manual driver setup, because the sealed node OS ships the driver, CDI spec, and device plugin before the node boots.
- Share a GPU across pods A slice is a scheduling token, not a fraction of the card. Learn when co-scheduling is safe and how to keep a whole GPU to one workload.
- Run NUMA-aligned workloads Pin a pod's CPUs and memory to one socket on multi-socket bare metal so latency-sensitive databases and real-time services stop paying the cross-socket tax.
- Run virtual machines with KubeVirt Run full virtual machines next to your containers with KubeVirt on bare-metal nodes, and plan for node churn so a VM disk backed by local NVMe survives.
Runtime classes
Secure workloads
- Overview The ways to isolate and harden a workload on Syself Autopilot, from a shared kernel up to a per-pod VM, and where to configure each one.
- Run a workload in a user namespace Map container root onto an unprivileged host UID with one field, so a container escape does not land as root on the node.
- Set security contexts on a workload Where security contexts fit in the workload-hardening ladder, with a pointer to the security page that owns the fields, the restricted example, and Pod Security Standards enforcement.
Configuration and delivery
- Provide config with ConfigMaps and Secrets Inject config and sensitive values into pods: env vars vs. files, live updates, and what a Secret actually protects.
- Pull images from a private registry Give pods credentials to pull from a private container registry, per namespace or per service account, and read your way out of ImagePullBackOff.
- Deploy an application with Helm Install packaged applications with Helm on Syself Autopilot, with the storage class and load balancer values a chart needs to run here.
- Deploy an application with Kustomize Adapt plain YAML to each environment without a template language, layering overlays over one base with built-in kubectl Kustomize.
- Deploy apps from Git with Argo CD Make Git the source of truth for your manifests so a controller reconciles the cluster back to the repo on every merge, drain, and node replacement.
- Progressive delivery and canary releases Send a new version to a slice of traffic first and promote or roll back on metrics, using Argo Rollouts.