Skip to content
Identical compute nodes side by side in open racks in dim light, each with a green light bar. In the video, nodes turn off from the outside in, one changes via amber to dark and a slot next to it turns on instead, until only three are lit; then the field grows back to full from the centre outwards.

Managed Kubernetes from data centres in Germany: We operate the control plane, a worker node costs what the instance costs in the catalogue. With hourly billing, you pay per second, up to the monthly price. Three ND3 nodes, 300 GB volumes and etcd backup: €267.60$310.42 net per month.

Control plane
€0.00$0.00
in tier Standard, per month
Availability
99.99%
from tier Highly available, according to SLA 4.2
Kubernetes
1.37
default 1.36
Test cluster per day
€7.65$8.87
3 × ND3, tier Standard, nodes onlyConfigure test cluster

Price, SLA, contract term and location

  • Control plane in tier Standard at no extra charge

    Per cluster and month

    €0.00$0.00

    We operate the control plane — the part of the cluster that decides what runs where — and in tier Standard we charge nothing for it.

  • Dedicated cores at list price

    ND3: 4 dedicated vCPU, 16 GB RAM, per month

    €77.60$90.02

    A worker node in the cluster costs what the instance costs in the catalogue: hourly rate, capped at the monthly price, with no surcharge for Kubernetes.

  • Load Balancer and drivers are included

    Load Balancer Layer 4

    included

    Every tier includes a Load Balancer Layer 4 at the entrance, the drivers for storage and Load Balancer (CSI and CCM) and the Cluster Autoscaler, which adds nodes when space is tight.

  • Control plane across three fire zones

    Committed availability

    99.99%

    From tier Highly available, the control plane runs across three structurally separated fire zones; tier Highly available costs €65.70$76.21 per cluster and month. What is committed is the availability of the API server.

  • Unmodified Kubernetes, cancellable monthly

    No contract commitment

    monthly

    The Kubernetes API remains unmodified: your manifests and Helm charts will continue to run on any other compliant cluster once the platform-specific names and annotations are adjusted.

  • Data centres in Germany

    Locations in two cities

    2

    You can choose from Frankfurt am Main and Düsseldorf; the platform is operated by a company under German and European law.

What we take over, what stays with you

Managed Kubernetes shifts work, it does not make it disappear. First comes what we take on without a ticket; then what stays with you.

Ten terms, briefly explained

Nodes
a single machine in the cluster on which your containers run; also worker node, worker for short
Node group
several nodes of the same size that grow and shrink together — in commands nodepool
Size
the fixed combination of vCPU, memory and local NVMe of a node, such as ND3 — in commands flavor
Autoscaler
the service that adds a node when space is tight and removes it later
Pod
the smallest unit in the cluster: one or more containers that start together
Volume
a disk that is assigned to a pod and survives its restart
Control plane
the part of the cluster that decides what runs where; English control plane
Minor version
the second part of the version number, for example 1.36
Registry
the storage location of your container images from which the nodes pull them
Gateway
the entrance from the outside into the cluster — a public address in front of your services; the older interface for this is called Ingress
A rack from the front, up close: at the top a closed, light grey control unit without a handle with a white light bar, below it a continuous crossbar, below that six dark compute nodes side by side, each with a recessed handle and a green light bar.

ENTRONYX CLOUD takes over

Without a maintenance contract: operations and maintenance of these parts are included in the prices on this page.

Control plane
API server, scheduler, controller manager and etcd — the state store of the cluster — run on our hardware. Operations and monitoring are our responsibility.
etcd backup
A bookable option in tier Standard, included in the tier price from tier Highly available. Every backup is encrypted.
Version upgrades
Pre-check, upgrading the control plane, then rolling upgrades of the node groups. If a version is phased out, we upgrade the control plane to the next one during the announced maintenance window.
Included components
CSI driver (storage connection), Cloud Controller Manager (connection to our API) and autoscaler, plus Load Balancer and Gateway at the cluster entrance — installed, versioned and updated with the cluster.
Registry
Operation of the Private Registry and checking of every uploaded layer against the vulnerability database.
Infrastructure
Machines and network on which the workers run — including replacement of defective hardware.

You keep

Everything that depends on your application — and which therefore no one can decide for you.

Your manifests
Deployments, services, Helm charts and the delivery chain. Argo CD or Flux — tools that sync the cluster from a Git repository — can be set up on request, but we do not operate them.
Sizing the node groups
Which size, how many nodes, which lower and upper limit the autoscaler gets. We do not add anything on our own.
Data in the volumes
The etcd backup contains object definitions, not user data. You back up the contents of persistent volumes via volume snapshots.
Permissions and network policies
RBAC roles (the access rights in the cluster), service accounts and NetworkPolicy. We do not set any rules in your cluster that you have not created.
Timing of the upgrade
As long as your version is maintained, you decide when the cluster moves to the next minor version.
Adaptation to removed APIs
The preflight run — the preliminary check before every version change — reports objects whose API version is no longer supported by the target version. Updating the manifest remains your responsibility.

Kubernetes pricing: you pay for nodes, not management

The control plane runs on our hardware, is updated and monitored by us — and costs €0.00$0.00 in tier Standard. This is not an introductory offer, but the model.

A Kubernetes cluster consists of two parts: the control plane decides what runs where, the worker nodes execute it. You are billed for the worker nodes and whatever storage and network you use with them; for the control plane, the tier surcharge only applies from tier Highly available onwards.

Worker nodes are ordinary cloud instances from the instance catalogue: the same hourly rate, the same cap at the monthly price. With hourly billing, a node that the autoscaler removes after two hours costs two hours.

The included traffic volume is tied to the node, not the cluster: each worker brings its own, and the total is available to the entire cluster. A node group of three ND3 nodes thus contributes 90 TB of outbound traffic per month, regardless of which node it flows through.

Included in the price

  • Control plane, tier Standard

    Per cluster and month; operations and monitoring are handled by us.

    €0.00$0.00
  • Load Balancer Layer 4

    TCP and UDP with Proxy Protocol v2, at the entry point of the cluster. Additional and larger Load Balancers are charged; the amount for the included one is credited.

    included
  • Public connection per node

    1 × IPv4 + /64 IPv6

    €0.00$0.00
  • Private Registry base fee

    You are charged for the storage used

    €0.00$0.00
  • Maintenance in the default window

    Fixed weekly window, the nodes are replaced one after the other. Times and notice period are governed by the SLA.

    included

The scope of services for each tier also includes: CSI and CCM drivers · Cluster Autoscaler.

Four compute nodes side by side fill the image, each with a recessed handle, green light bar and ventilation grille. At the top edge of the image, the crossbar and the lower edge of the control unit protrude.

What is extra

Worker node ND34 dedicated vCPU, 16 GB RAM; with hourly billing, billed to the second, capped at this amount
€77.60$90.02per node and month
Persistent volumeBlock Storage NVMe, RWO (one node writes)
€0.0860$0.0998per GB and month
Shared file systemShared File Storage, RWX (multiple nodes write) via NFS 4.1
€0.0518$0.0601per GB and month
Private Registry storageRegistry Standard, the default; without base fee
€0.0070$0.0081per GB and month
etcd backup in tier StandardOption “Snapshots (7 days)”; from tier Highly available, included in the tier price
€9.00$10.44per cluster and month
Additional Load Balancer Layer 4The first Load Balancer is included in the cluster
€11.98$13.90per month
Data traffic above the included volume30 TB per ND3 node and month are included
€1.09$1.26per TB
Egress gatewayOnly for nodes without a public address: their way out, as a redundant pair
€39.98$46.38per month
Highly available tierControl plane of this tier; the etcd backup is included
€65.70$76.21per cluster and month
Enterprise tierControl plane of this tier; the etcd backup is included
€177.84$206.29per cluster and month

Three control plane tiers: price, SLA and evidence

All three tiers deliver the same Kubernetes version, the same drivers and the same workers. What differs is primarily the resilience of the control plane, the node limit and the scope of evidence.

Standard

Control plane free of charge — you only pay for the worker nodes.

€0.00$0.00Control plane, per cluster and month

Example cluster in this tier

€267.60$310.42net per month

3 × ND3, 300 GB volumes, etcd backup

SLA
99.9%
Max. workers
100
  • Managed control plane
  • Automatic upgrades
  • CSI and CCM drivers
  • Cluster Autoscaler
  • Ingress with Load Balancer

Highly available

recommended

Control plane distributed across three fire zones.

€65.70$76.21Control plane, per cluster and month

Example cluster in this tier

€324.30$376.19net per month

3 × ND3, 300 GB volumes, etcd backup

SLA
99.99%
Max. workers
500
  • Everything from Standard
  • 3-zone control plane
  • etcd backup every 15 minutes
  • Private API endpoint
  • Audit log export

Enterprise

For regulated environments requiring evidence.

€177.84$206.29Control plane, per cluster and month

Example cluster in this tier

€436.44$506.27net per month

3 × ND3, 300 GB volumes, etcd backup

SLA
99.99% with service credit
Max. workers
2,000
  • Everything in Highly available
  • Dedicated control plane
  • Multi-region federation
  • CIS benchmark hardening
  • BSI C5 attestation
  • 24/7 escalation path
The three Kubernetes tiers in a feature comparison
FeatureStandard€0.00$0.00 / monthHighly available€65.70$76.21 / monthEnterprise€177.84$206.29 / month
Availability commitmentmeasured by the availability of the API server; the SLA service credit scale applies in every tier99.9%99.99%99.99%
Worker nodes per cluster1005002,000
Control planeone fire zone, managedthree fire zones, active/activededicated, without other tenants
etcd backupdaily snapshots, available as an optionincluded in the tier priceincluded in the tier price; WORM lock available via the “Vault backup (365 days)” backup tier
API endpointpublic, with IP allowlistadditionally private in the vRack (your private network)additionally private in the vRack
Private registrysee Registry sectionone registry per projectmultiple registries, mirrors includedmultiple registries, mandatory signatures possible
Audit log7 days in the consoleExport to Object Storage or LokiExport, audit-proof
Hardeningdefault settings of the Kubernetes projectdefault settings of the Kubernetes projectCIS benchmark (hardening catalogue), documented
CertificatesISO 27001ISO 27001ISO 27001 and BSI C5
SupportResponse times according to SLA: Basic support is included in the price of each tier, initial response in 8 hours for critical incidents, available Monday to Friday from 08:00 to 18:00.TicketTicketTicket and escalation path around the clock

Faster initial response than with Basic support? Support tiers in the SLA

Questions about the Enterprise tier or the evidence? Arrange a callback

Your cluster, item by item

Set the tier, workers and volumes: the calculator shows each item with quantity and unit price and passes the selection to the configurator — the default is the example cluster with 3 × ND3, each with a 100 GB volume and etcd backup.

Control plane tier

We operate the control plane in every tier; the tier determines its distribution and the committed availability (SLA). Workers and volumes cost the same in every tier.

Worker size
Dedicated cores
Shared cores

Price per node and month. For production clusters, we recommend sizes with dedicated cores.

1 worker20 workers

All workers in this node group have the same size. You can set up additional groups and autoscaling in the configurator.

without1,000 GB

Persistent storage on Block Storage NVMe, €0.0860$0.0998 per GB and month. The provisioned amount is billed.

Cluster state backup (etcd)

The etcd state store contains every object you create in the cluster — not the data on your volumes. If it is deselected, the backup is your responsibility. In tiers Highly available and Enterprise, it is included in the tier price.

Node group with graphics cards

NG-RTX4000 · 1 × NVIDIA RTX PRO 4000 Blackwell SFF, 24 GB GDDR7 · €214.00$248.24 per node and month

Nodes with graphics cards form a separate node group, for example for inference. Any size in the catalogue is permitted as a worker, including the ten GPU sizes — at the hourly rate of the instance and capped at its monthly price. The device plugin for NVIDIA is rolled out when the group is created.

A node group with graphics cards may scale down to zero: with hourly billing, nodes that the autoscaler shuts down cost nothing from the moment they are shut down.

All GPU sizes with hourly rate

Calculation per month

Location Düsseldorf, net catalogue prices

Monthly costs of the selected cluster at location Düsseldorf, net, per item with quantity, unit price and total
ItemTotal
Control plane StandardSLA 99.9%1 × €0.00$0.00€0.00$0.00
Worker ND34 vCPU, 16 GB RAM, 160 GB NVMe3 × €77.60$90.02€232.80$270.05
Block Storage NVMepersistent volumes, 100 GB per worker300 GB × €0.0860$0.0998 / GB€25.80$29.93
etcd backupSnapshots (7 days)1 × €9.00$10.44€9.00$10.44

Amounts per item rounded individually, total converted as a whole.

Net total per month

€267.60$310.42

from four items

€318.44$369.40 incl. 19 % VAT.

Cluster per hour €0.3666$0.4253

Calculated for continuous operation over the entire month; with hourly billing, the monthly price is the upper limit. One load balancer Layer 4 is included in the cluster. Not included are the Private Registry and additional load balancers. You select these items in the configurator, as well as the location, version and additional node groups.

Capacity of all nodes

vCPU
12
Memory
48 GB
Local NVMe
480 GB
Included traffic
90 TB
Sizes for node groups: local NVMe and price per month or hour

A size defines the vCPU, memory and local NVMe of a node as a fixed combination; on the command line and in Terraform it is called flavor. We do not recommend sizes with shared cores for production clusters. Kubernetes' own processes run continuously on every node — with shared cores, they consume part of the computing time allocated to the node even before the application runs.

Select pricing unit

Monthly price is also the cap for hourly billing

Sizes suitable for node groups with vCPU, memory, local NVMe and price per hour or month
ConfigurationvCPURAMLocal NVMePrice / month
ND2AMD EPYC (dedicated)28 GB80 GB€38.80$45.01
ND3AMD EPYC (dedicated)416 GB160 GB€77.60$90.02
ND4AMD EPYC (dedicated)832 GB240 GB€138.99$161.23
ND5AMD EPYC (dedicated)1664 GB360 GB€276.49$320.73
NM4AMD EPYC (dedicated)864 GB320 GB€193.30$224.23
NA4Ampere Altra (shared)816 GB160 GB€21.49$24.93
NA5Ampere Altra (shared)1632 GB320 GB€41.49$48.13
NG-RTX4000Intel Core i5-13500 (dedicated)2064 GB1 TB€214.00$248.24
NG-L4AMD EPYC (dedicated)848 GB400 GB€540.00$626.40

GPU sizes — NG-RTX4000 and NG-L4 in this list — belong in a separate node group with the taint nvidia.com/gpu. A taint is a restriction mark on the node: only workloads that really need a graphics card and explicitly tolerate the mark end up there.

Three clusters you can recalculate

Examples, not customers: no names, no quotes. Every amount is calculated using the rates on this page, and every example can be imported into the configurator as a template.

  • Three compute nodes side by side with a green light bar, below each a small drawer front; the remaining slots in the rack are closed with blanking panels.

    Customer portal

    Web application with database

    Initial situation

    A customer portal with a database in the cluster. If a fire zone fails, the Kubernetes API should remain accessible, and the data is stored on dedicated volumes.

    Decision

    Tier Highly available, committed at 99.99% availability; plus 3 × ND3 and 300 GB Block Storage NVMe, i.e. 100 GB per node. The amount includes the control plane, nodes and volumes; a Load Balancer Layer 4 is included in the cluster, the etcd backup in the tier. A Private Registry is not included.

  • Ten plugged-in compute nodes in a row: three light up green, the light bars on the other seven are dark.

    Analysis

    Batch processing with load peaks

    Initial situation

    Nightly evaluations and export runs: a few hours of high load, otherwise low. The services that accept and queue jobs run continuously.

    Decision

    Tier Standard with two node groups: 2 × ND2 run the continuous services; the second group keeps 1 × ND4 on standby so that the first job does not wait for a node to start, and grows with the Cluster Autoscaler to up to eight nodes. The amount includes the three nodes of the lower limit and the etcd backup “Snapshots (7 days)”; one Load Balancer Layer 4 is included in the cluster. Volumes and a Private Registry are not included. Each additional node of the second group costs €0.1904$0.2209 per hour; if each group reaches its limit, it is at most €1,198.52$1,390.28 per month.

  • Three narrow compute nodes and two double-width ones with a round ventilation panel, all five with a green light bar; closed slots to the left of them.

    Language model

    Inference with graphics cards

    Initial situation

    A language model answers requests from an application. The application needs ordinary nodes, the model graphics cards — both in the same cluster, in separate node groups.

    Decision

    Tier Standard with two node groups: 3 × ND3 with 300 GB Block Storage NVMe for the application, plus 2 × NG-RTX4000 as a separate group for the model. The amount includes both node groups, the volumes and the etcd backup “Snapshots (7 days)”; a Load Balancer Layer 4 is included in the cluster. A Private Registry is not included.

In three steps to a running cluster

From the first cluster to the first deployment — with kubectl, Helm and the GitOps toolchain you already use.

Three free-standing, half-height racks spaced apart in front of a light wall; in each, a control unit at the top lights up white, the slots below are closed with blanking panels.

Create cluster

You choose one of the three tiers and a location; Frankfurt am Main and Düsseldorf are available. The control plane is ready in under five minutes; we set it up and operate it. In tier Standard it is not charged; from tier Highly available it runs across three fire zones, and its availability is committed at 99.99%.

Choose tier and location

The same three racks, now populated: on the left six narrow compute nodes, in the middle three double-width ones, on the right two double-width ones with a round ventilation panel and next to them two closed slots. Each node has a green light bar, above which the three control units light up white.

Size node groups

A node group combines nodes of the same size; in the configurator you create up to six groups, with graphics cards as a separate group alongside the rest. You set a lower and upper limit per group. In between, the Cluster Autoscaler adds nodes as soon as pods — the smallest units in which your containers run — cannot find space, and releases nodes whose pods have space on the remaining ones. Provisioning the instance behind a new node takes on average 35 seconds, guaranteed under 60 seconds; after that, the node registers with the cluster.

Calculate costs

The middle rack up close: below the control unit with a white light bar sits the registry unit, a low strip of two rows of small, closed compartments. Below that are three double-width compute nodes with a green light bar, the neighbouring racks partially visible on the left and right.

Deploy or migrate

You download the kubeconfig, the access file for the cluster, and continue working with kubectl, Helm and GitOps tools like Argo CD or Flux as usual: the cluster speaks the Kubernetes API, there is no proprietary interface in between. If your cluster is already running elsewhere, you migrate it yourself: create a new cluster, transfer the container images to the Private Registry, point manifests or the GitOps source to the new cluster, finally transfer the volume data and update the DNS record. Both clusters run side by side until the new one carries the traffic.

Migrate existing cluster

Data location, separation, evidence

What a procurement or data protection audit asks first: where the cluster runs, what it is separated from and what can be proven — with the data processing agreement (DPA) under Art. 28 GDPR, the certificate according to ISO 27001 and the attestation according to BSI C5:2020.

Evidence and documents

Data location and law

A cluster runs at the location you select during the order — you can choose Frankfurt am Main and Düsseldorf, i.e. data centres in Germany. The platform is operated by a company under German and European law and without a parent company in a third country. The data processing agreement (DPA) under Art. 28 GDPR is included with the main contract.

Locations for clusters
Frankfurt am Main (fra1), Düsseldorf (dus1)
Registered office
Germany
Applicable law
GDPR, BDSG, German law
Corporate affiliation
No parent company, no holding company in a third country
Data processing agreement (DPA)
Art. 28 GDPR, integral part of the main contract

Separation

The API endpoint of a cluster is publicly accessible and restricted via an IP allowlist; from the Highly available tier, it is additionally available privately in the vRack, your private network. In the Enterprise tier, the control plane runs dedicated, without other tenants.

API endpoint, Standard
public, with IP allowlist
API endpoint from Highly available
additionally private in the vRack (your private network)
Control plane, Enterprise
dedicated, without other tenants

Certificates

A certificate under ISO 27001 is in place for the information security management system. Under BSI C5:2020, a Type 2 attestation is in place: the opinion of an auditing firm on the effectiveness of the controls over an audit period of twelve months, not a certificate. Its scope names Kubernetes as a service; in the tier table, the C5 attestation is listed for the Enterprise tier.

The C5:2026 version was published on 7 April 2026 and applies to audit periods from 1 June 2027 — until then, C5:2020 applies.

ISO 27001
Certificate · Valid until 30 November 2027 · recertification every three years
BSI C5:2020
Attestation · Audit period 1 July 2025 to 30 June 2026 · follow-up audit in progress
Cluster locations in the scope of both the certificate and the attestation
every two
Evidence per tier
ISO 27001 in every tier, BSI C5:2020 additionally in Enterprise

Supply chain and log

The Private Registry checks images for known vulnerabilities; in the Enterprise tier, a signature requirement for images can additionally be set. The audit log, the log of accesses to the Kubernetes API, is available in the console or as an export depending on the tier.

Audit log, Standard
7 days in the console
Audit log from Highly available
Export to Object Storage or Loki
Audit log, Enterprise
Export, audit-proof
Signature requirement
possible in Enterprise
Hardening, Enterprise
CIS benchmark (hardening catalogue), documented
A long row of identical compute nodes with green light bars. In the video, it pans by; one node after another briefly changes via amber to dark and lights up green again, never two at the same time.

If a node fails, its pods restart on the remaining ones. During a version upgrade, nodes are replaced one by one; PodDisruptionBudgets — the minimum number of running pods per application — are respected.

What is already running in the cluster

Four components connect Kubernetes to our infrastructure. They are installed, versioned and updated with the cluster — without you having to maintain a Helm chart.

Yellow fibre optic cables with blue connectors, plugged into a row of transceivers at the back of a server.

CSI driver

The storage driver csi.block.entronyx.cloud provisions volumes on Block Storage NVMe, csi.file.entronyx.cloud mounts NFS shares. Four StorageClasses (storage profiles) are pre-installed, nvme-delete is the default. Which class a location serves follows the storage catalogue: Shared File Storage is available in Frankfurt am Main and Düsseldorf, Block Storage Capacity in Frankfurt am Main and Düsseldorf.

Access modes
RWO (one node) on block, RWX (multiple) via NFS, where the location provides it
Online expansion
yes, without restarting the pod
Snapshots
VolumeSnapshotClass, incremental
Topology
Volume remains bound to its fire zone

Cloud Controller Manager

The CCM connects Kubernetes to our API: it sets the provider ID (the ID of the underlying instance) on each node, removes deleted instances from the cluster and creates a public address for each service of type LoadBalancer.

Load Balancer
annotatable via service.beta.entronyx.cloud/…
Method
round-robin, least-connections, source-hash
Proxy Protocol
v2, for real client IP
Routes
Pod network is announced in the vRack

Cluster Autoscaler

You set a lower and an upper limit per node group. If a pod cannot be scheduled due to a lack of capacity, the autoscaler creates a new node. Instance provisioning: on average 35 seconds, guaranteed under 60 seconds. Node groups with graphics cards and for batch runs may scale down to zero; the configurator creates each group with at least one node. The number of pods is regulated by the HorizontalPodAutoscaler: from Kubernetes 1.37, it scales down to zero pods — only for object and external metrics and as a beta feature that is shipped enabled.

Selection process
least-waste
Scale down
after 10 minutes below 50% utilisation
Protection
PodDisruptionBudgets are respected
Scale from zero
yes, for node groups with graphics cards and for batch runs

Ingress and network: Gateway API instead of ingress-nginx

Cilium, the cluster's network plugin, runs in eBPF mode and replaces kube-proxy. You control external traffic via the Gateway API, the successor to the Ingress interface: Cilium implements Gateway, HTTPRoute, GRPCRoute, TLSRoute, TCPRoute and UDPRoute itself; no additional controller runs for this. Ingress objects with the class cilium continue to be served by the network plugin. Certificates are issued by cert-manager, via DNS-01 against our Anycast DNS. The pod network is a /16 by default.

Network plugin (CNI)
Cilium, eBPF, without kube-proxy
Inbound
Gateway API v1.6, implemented by Cilium
Ingress
Class cilium, without the annotations of ingress-nginx
Network policies
NetworkPolicy and CiliumNetworkPolicy
Certificates
cert-manager, DNS-01
Observability
Hubble (recording of network flows), 24-hour retention

Versions and upgrade path

There are three minor versions to choose from for new clusters. A new version can be selected no later than six weeks after its release by the Kubernetes project; it becomes the default as soon as the network plugin, Cluster Autoscaler and Rancher support it.

This is why 1.36 is the default today and 1.37 is selectable: the network plugin and Rancher do not yet list 1.37 in their compatibility list, and the Cluster Autoscaler has not yet been released for 1.37. Clusters on 1.37 can therefore not yet be connected to Managed Rancher.

The Kubernetes project maintains each minor version for around fourteen months: twelve with all patches, followed by two in which only security and critical patches are released. The end of these fourteen months is listed in the version table under “patches until”. This is followed by two months of transition, in which no new patches from the Kubernetes project are released. If you have not upgraded yourself by then, we raise the control plane to the next minor version in the announced maintenance window — from the month listed there under “upgrade from”. We do not charge a surcharge for older versions until then. “Available since” states the month from which a version can be selected with us; the fourteen months count from its release by the Kubernetes project.

Kubernetes versions: available since, Kubernetes project patches until, control plane upgrade from
Version
1.37 New available since 10/2026 patches until 10/2027 upgrade from 12/2027
1.36 Default available since 04/2026 patches until 06/2027 upgrade from 08/2027
1.35 maintained available since 12/2025 patches until 02/2027 upgrade from 04/2027
1.34 Expiring available since 08/2025 patches until 10/2026 upgrade from 12/2026

As of: October 2026

Upgrade process

  1. 01

    Preflight

    before the maintenance window

    Checking for API versions that no longer exist in the target version, missing PodDisruptionBudgets (the minimum number of running pods per application) and add-ons whose version does not match the target version. The result is a list, not a guess.

  2. 02

    Control plane

    5 to 15 minutes

    The control plane is upgraded first. In the Highly available tier, the API server remains accessible throughout the entire process because the three instances switch one after the other.

  3. 03

    Node groups

    rolling

    Each node group is renewed with surge 1: a new node is added, an old one is cordoned, drained and removed. PodDisruptionBudgets are respected; if necessary, the operation waits.

  4. 04

    Version skew

    Limit

    There may be a maximum of three minor versions between the API server and the kubelet — the service that starts the containers on each node. As long as this gap is maintained, node groups may intentionally stay behind — for example, a group with particularly sensitive workloads. However, a group with a gap of three versions blocks the next upgrade of the control plane: this group must catch up first.

  5. 05

    Rollback

    only forwards

    A downgrade of the control plane is not possible because etcd migrates its schema. The way back is via a new cluster in the old version and applying your manifests.

What changes per version

For each version, three changes that matter when operating a managed cluster — where there is a maturity level, it is stated.

Kubernetes 1.37

New
  • The HorizontalPodAutoscaler scales down to zero pods for object and external metrics (beta, enabled).
  • Pod certificates give a workload its own identity (stable).
  • The etcd state store ships in version 3.7.

Kubernetes 1.36

Default
  • User namespaces map the root user in the container to an unprivileged user on the node (stable).
  • Image volumes mount an image as a volume in a pod (stable).
  • For this version, the containerd project recommends the 2.x series of the container runtime; the 1.7 series has not been maintained since 30 September 2026.

Kubernetes 1.35

maintained
  • In-place pod resize changes the CPU and memory of a running pod without a restart (stable).
  • A service prefers to keep traffic on the same node or in the same fire zone (stable).
  • On nodes with cgroup v1, the older resource management of the Linux kernel, the kubelet no longer starts by default.

Behaviour with removed API versions

A removed API version does not delete any objects. What is in the cluster stays there and continues to run — only the next apply, the next Helm upgrade or the next GitOps sync will fail, often months after the upgrade. The preflight run therefore searches the entire object inventory and not just your manifests in the repository. If it finds a usage, the upgrade is aborted instead of postponing the error into the future. Since 1.32, the Kubernetes project guide does not list any further removed stable or beta API versions.

Six removed API versions and their replacements
API versions removed by the Kubernetes project that the preflight run reports
API version
networking.k8s.io/v1beta1 Affected objects: Ingress, IngressClass Removed in: 1.22 Replacement: networking.k8s.io/v1
batch/v1beta1 Affected objects: CronJob Removed in: 1.25 Replacement: batch/v1
policy/v1beta1 Affected objects: PodDisruptionBudget Removed in: 1.25 Replacement: policy/v1
autoscaling/v2beta2 Affected objects: HorizontalPodAutoscaler Removed in: 1.26 Replacement: autoscaling/v2
flowcontrol.apiserver.k8s.io/v1beta2 Affected objects: FlowSchema, PriorityLevelConfiguration Removed in: 1.29 Replacement: flowcontrol.apiserver.k8s.io/v1
flowcontrol.apiserver.k8s.io/v1beta3 Affected objects: FlowSchema, PriorityLevelConfiguration Removed in: 1.32 Replacement: flowcontrol.apiserver.k8s.io/v1

For CronJob and PodDisruptionBudget, the new version specification in the manifest is usually sufficient. For Ingress and HorizontalPodAutoscaler, field names also change. What else a version changes is announced in the release notes when it is released.

What else has changed since 1.33

These changes do not remove an API version, and no apply fails because of them: the object is accepted and behaves differently — or the underlying component no longer receives fixes.

Five behaviour changes and their consequences
Behaviour changes without removed API version: when they apply and what they mean for your cluster
Change
Endpoints API deprecated since 1.33 The API is deprecated but not removed. Migrate tools and controllers that read or write Endpoints to EndpointSlices.
gitRepo volume permanently disabled since 1.36 Pods with a gitRepo volume no longer start.
Service.spec.externalIPs deprecated since 1.36 The field continues to work for now; removal is planned for 1.43.
SELinuxMount enabled since 1.37 Only affects nodes with SELinux: pods that mount the same volume with different SELinux labels may not start there.
ingress-nginx retired since 24 March 2026 The project no longer receives security fixes. The successor is the Gateway API; the Ingress API itself remains.

Limits

The values are hard limits, not recommendations. If you want to max them out, you should talk to us first about the distribution of the node groups — many small nodes in one group behave differently than a few large ones in several groups.

Technical upper limits per Kubernetes tier
FeatureStandardHighly availableEnterprise
Worker nodes per cluster1005002,000
Node groups per cluster666
Load balancers per cluster888
Clusters per project525unlimited
Pods per node110110110
etcd database size8 GB8 GB8 GB
Persistent volumes per nodeLimit of the block storage connection161616

Cluster as code

Clusters, node groups, the Private Registry and autoscaling limits will become resources in the Terraform provider and can then also be set up via the command line. Both are in preparation; the examples below show the draft.

Create clusters and node groups

Command line
# Create cluster, tier ha: control plane across three fire zones
entronyx kube cluster create prod-fra \
  --version 1.36 --tier ha --region fra1 --private-endpoint
 
# Node group with autoscaling between 3 and 12 workers
entronyx kube nodepool create workers \
  --cluster prod-fra --flavor nd3 --min 3 --max 12 --autoscale
 
# Merge the credentials into the existing kubeconfig
entronyx kube kubeconfig prod-fra --merge
 
kubectl get nodes -o wide
kubectl get storageclass
# NAME                    PROVISIONER
# nvme-delete (default)   csi.block.entronyx.cloud
# nvme-retain             csi.block.entronyx.cloud
# capacity-delete         csi.block.entronyx.cloud
# shared-nfs              csi.file.entronyx.cloud
The kubeconfig — the access file for kubectl — contains a short-lived token that is renewed via the ENTRONYX login service. For CI systems, you create a service account with a limited role instead.
main.tf
resource "entronyx_kube_cluster" "prod" {
  # Tier ha: control plane across 3 fire zones.
  # entronyx_vrack.prod is your private network, created separately.
  name             = "prod-fra"
  region           = "fra1"
  version          = "1.36"
  tier             = "ha"
  private_endpoint = true
  vrack            = entronyx_vrack.prod.id
 
  etcd_backup {
    interval = "15m"
  }
}
 
resource "entronyx_kube_nodepool" "workers" {
  cluster   = entronyx_kube_cluster.prod.id
  name      = "workers"
  flavor    = "nd3"
  autoscale = true
  min_nodes = 3
  max_nodes = 12
  labels    = { workload = "general" }
}
 
resource "entronyx_kube_nodepool" "inference" {
  cluster   = entronyx_kube_cluster.prod.id
  name      = "inference"
  flavor    = "ng-l4"
  autoscale = true
  min_nodes = 0 # scales down to zero
  max_nodes = 4
 
  taints {
    key    = "nvidia.com/gpu"
    value  = "true"
    effect = "NoSchedule"
  }
}
Changing the version triggers an upgrade — first of the control plane, then rolling across the node groups.

Service, volume and ingress in the cluster

service-pvc.yaml
apiVersion: v1
kind: Service
metadata:
  name: web
  annotations:
    service.beta.entronyx.cloud/proxy-protocol:    "true"
    service.beta.entronyx.cloud/health-check-path: "/healthz"
    service.beta.entronyx.cloud/algorithm:         "least-connections"
spec:
  # The cloud controller creates the public IP
  type: LoadBalancer
  selector:
    app: web
  ports:
    - port: 443
      targetPort: 8443
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: data
spec:
  # nvme-retain: the volume survives deletion of the claim
  storageClassName: nvme-retain
  accessModes: [ReadWriteOnce]
  resources:
    requests:
      storage: 100Gi
Service and PersistentVolumeClaim are core Kubernetes. The annotations and the name of the StorageClass are tied to the platform: without the annotations, the Load Balancer gets round-robin without Proxy Protocol; without storageClassName, nvme-delete applies.
gateway.yaml
# HTTP entry via the Gateway API — instead of the Service of
# type LoadBalancer in service-pvc.yaml. The Gateway brings its own
# load balancer, terminates TLS and then talks to the backend
# unencrypted; the Service stays inside the cluster
apiVersion: v1
kind: Service
metadata:
  name: web
spec:
  type: ClusterIP
  selector:
    app: web
  ports:
    - port: 80
      targetPort: 8080
---
apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
  name: eingang
  annotations:
    # cert-manager issues the certificate and creates the Secret
    cert-manager.io/cluster-issuer: <your-issuer>
spec:
  gatewayClassName: cilium
  listeners:
    - name: https
      protocol: HTTPS
      port: 443
      hostname: app.example.org
      tls:
        mode: Terminate
        certificateRefs:
          - name: app-example-org-tls   # Secret with the certificate
---
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: web
spec:
  parentRefs:
    - name: eingang
  hostnames: [app.example.org]
  rules:
    - backendRefs:
        - name: web   # the Service above
          port: 80
Gateway and HTTPRoute are Gateway API objects; the class name cilium is tied to the platform. The Gateway is the entry point for HTTP: Cilium implements it, the listener terminates TLS and the HTTPRoute forwards the requests to the web service. One of the two ways is sufficient per service — each creates its own Load Balancer.

Kubernetes documentation

A rack from close up: under the crossbar the registry unit with two rows of small, closed compartments, below that the heads of three compute nodes with recessed grips and a green light bar.

The Private Registry has no base fee: you are charged for the storage used after deducting duplicate layers, and a pull from your own cluster does not leave the network.

Your images are stored where the nodes are

The Private Registry is a managed container registry per project: OCI-compliant (the open standard for container images), at the same location as the cluster, with vulnerability scanning on upload and retention rules that prevent the storage from filling up unnoticed.

Scan on upload

Every new layer is checked against the vulnerability database after the push, before the image can be delivered. The finding is attached to the digest — the checksum of the image — and not to the tag, the freely assigned name of a version: a newly set tag inherits it, a new build does not.

Triggered by
every push, without intervention
Rescan
daily against the updated database
Block
by severity; critical and above by default
Exceptions
per repository, with expiry date and reason

Retention rules

Without a rule, a registry grows monotonically: every build stores a version, none disappear. The rules work per repository and can be viewed in a dry run before execution.

Retain
the last n versions per repository
Protection pattern
tags like v* or release-* always remain
Untagged
Untagged manifests are dropped after an adjustable period
Archive
older versions move to the archive class

Connection to the cluster

The cluster signs in with a read-only robot account. The access token is stored as an imagePullSecret — the access secret for retrieving images — in the namespace and is inherited via the service account by all pods running under it.

Account type
robot account, not your user account
Permissions
separated by pull, push and delete
Validity
token with expiry date, renewable
Bound to
the service account instead of every deployment

Mirror of public registries

A rollout across many nodes requests the same image many times simultaneously — exactly the case where public registries throttle anonymous requests. The mirror fetches the image once and then delivers it from our network.

Effect
no throttling during rollout
First request
is passed through and cached
Origin
Digest remains identical to the original
Network
retrieval from the cluster does not leave our network

Storage classes and prices

The registry has no base fee. It stores layers and manifests in object storage and is charged at its rates — €0.0070$0.0081 per GB and month by default. For 250 GB of used storage, that is €1.75$2.03 net per month. The actual usage after removing duplicate layers is counted, not the sum of the image sizes.

Private Registry storage classes, net per month — “Example / month” is the price per GB multiplied by the example quantity
Storage classper GB / month
Registry StandardDefault. Hosts application images, base images and Helm charts.Basis: Object Storage Standard Minimum quantity: 1 GB Example quantity: 250 GB Example / month: €1.75$2.03€0.0070$0.0081
Registry PerformancePure NVMe backend for large images and rollouts across many nodes simultaneously.Basis: Object Storage Performance Minimum quantity: 1 GB Example quantity: 250 GB Example / month: €4.50$5.22€0.0180$0.0209
Registry ArchiveTarget for retention rules: expired versions that must be kept for evidence purposes.Basis: Cold Archive Minimum quantity: 1,000 GB Example quantity: 1,000 GB Example / month: €2.40$2.78€0.0024$0.0028

Set up and use in the cluster

Registry, robot account, scan rule, retention and mirror are five commands. In the cluster, it stays plain Kubernetes: a Secret of type dockerconfigjson, bound to the service account of the namespace.

registry-einrichten.sh
# Create registry — storage class and location
# as with Object Storage
entronyx registry create prod \
  --region fra1 --class standard --quota 250
 
# Robot account with read access only, for the cluster's nodes
entronyx registry robot create ci-pull \
  --registry prod --scope "repo:*:pull" --ttl 90d
 
# Scan policy: images with a critical vulnerability are
# not served
entronyx registry policy set prod \
  --scan-on-push --block-severity critical --block-unscanned
 
# Retention: the last 10 versions per repository are kept,
# untagged manifests are removed after 7 days
entronyx registry retention set prod \
  --keep-latest 10 --keep-tagged "v*,release-*" \
  --purge-untagged-after 7d --archive-after 180d
 
# Mirror for a public registry: pulls then go through us
entronyx registry mirror add prod \
  --upstream docker.io --cache-ttl 24h
 
# Store the robot account's credentials as an imagePullSecret
# in the cluster
entronyx registry robot token ci-pull --registry prod \
    --format docker \
  | kubectl create secret generic entronyx-registry \
      --namespace produktion --type kubernetes.io/dockerconfigjson \
      --from-file=.dockerconfigjson=/dev/stdin
The robot account gets read-only permissions. A token with write access belongs in the build chain, not in the cluster.
registry-secret.yaml
apiVersion: v1
kind: Secret
metadata:
  name: entronyx-registry
  namespace: produktion
type: kubernetes.io/dockerconfigjson
stringData:
  # Output of: entronyx registry robot token ci-pull --format docker
  .dockerconfigjson: |
    { "auths": { "prod.registry.entronyx.cloud":
        { "auth": "<base64>" } } }
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: default
  namespace: produktion
# New pods under this service account receive the Secret;
# it then need not be repeated in every Deployment
imagePullSecrets:
  - name: entronyx-registry
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web
  namespace: produktion
spec:
  selector:
    matchLabels: { app: web }
  template:
    metadata:
      labels: { app: web }
    spec:
      containers:
        - name: web
          image: prod.registry.entronyx.cloud/team/web:1.8.2
        # The mirror replaces the public registry: the same
        # line, a different origin, no rate limit during rollout
        - name: cache
          image: prod.registry.entronyx.cloud/mirror/valkey/valkey:8
The secret on the service account saves repeating it in every deployment. The mirror path mirror/… replaces the public origin without changing the digest.

One interface for a fleet of clusters

Managed Rancher is Rancher as a managed service: you sign in, connect clusters and assign permissions. Updates, backup and availability of the Rancher instance are our responsibility.

State of all clusters side by side

Rancher shows the state, utilisation and events of all connected clusters side by side. The cluster view is a view of the same API server that kubectl addresses — no second state that could diverge.

Access
one login process for all clusters
kubectl
built-in console, or continue locally
Events
merged across all clusters
Operations
the instance is updated by us

Clusters outside ENTRONYX, too

An external cluster is imported: Rancher outputs a manifest that starts an agent in the target cluster and establishes the connection from the inside out. The external API server does not need to be publicly accessible for this. Rancher 2.15 imports compliant clusters of versions 1.34 to 1.36; the range shifts with each Rancher version. Clusters on 1.37 — including your own with us — can be connected as soon as Rancher supports the version.

Requirement
compliant cluster, version 1.34 to 1.36
Connection
originating from the agent, via TLS
Depth of intervention
observe and apply, no modifications
Detach
remove agent, the cluster continues to run

Federated permissions instead of a second user list

Rancher does not maintain its own user management. Whoever logs in comes from the same directory service as in the console. The roles come from the rights federation: one group, one assignment, effective in all assigned clusters.

Login
OIDC (login standard) against your directory service
Roles
from the rights federation, not maintained twice
Scope
per instance, cluster or project
Revocation
leaving the group takes effect immediately

Application catalogue and fleet rollout

Helm charts, the packages for Kubernetes applications, can be rolled out simultaneously from a shared catalogue to a selection of clusters — filtered by label, for example to all clusters with the label stage=produktion.

Source
its own catalogue or your Helm repositories
Selection
via labels, not via lists
Order
gradual, stopping on errors
Reconciliation
deviations are reported

From empty Rancher to fleet

  1. 01

    Create instance

    a few minutes

    Select a location, connect a directory service. The instance gets its own name under our domain and a certificate that is renewed automatically.

  2. 02

    Adopt your own clusters

    via the API

    We connect clusters from your ENTRONYX projects via the API. You do not apply a manifest for this.

  3. 03

    Import third-party clusters

    a manifest

    For clusters with other providers or in your own data centre, Rancher generates a manifest. When applied, it starts the agent that establishes the connection from the inside.

  4. 04

    Assign permissions

    from the identity federation

    Groups are assigned roles — for the instance, for individual clusters, or for projects within a cluster. There is no second user list that needs to be maintained.

  5. 05

    Start operations

    running

    Roll out catalogue applications, compare states, track events. For daily work, kubectl remains usable as before: Rancher complements the tool and does not replace it.

rancher-einrichten.sh
# Create the Rancher instance; sign-in uses the same
# directory service as the console
entronyx rancher create zentral --region fra1 --sso oidc
 
# Attach an ENTRONYX cluster — no manifest needed; the connection
# is made through the API
entronyx rancher attach zentral --cluster prod-fra
 
# Import an external cluster: Rancher prints a manifest
# that starts an agent in the target cluster
entronyx rancher import zentral --name kunde-onprem > agent.yaml
kubectl --kubeconfig ~/.kube/onprem apply -f agent.yaml
 
# Permissions come from the identity federation,
# not from a second user list
entronyx iam binding create \
  --group "team-plattform" --role rancher.clusterOwner \
  --scope zentral
entronyx iam binding create \
  --group "team-anwendung" --role rancher.projectMember \
  --scope zentral/produktion
Importing an external cluster is the only step where you apply a manifest yourself — it starts an agent in the target cluster.

When you need this — and when you don't

Rancher is an additional component in your chain. With a single cluster and a team that works with kubectl anyway, it adds more interface than benefit. From the third cluster onwards, or at the latest with separate teams or locations, the calculation flips. Tier Enterprise is intended for a fleet across multiple locations.

Operations without and with Managed Rancher in comparison
FeatureOne cluster, one teamMultiple clusters, teams, or locations
Accessone kubeconfig, maintained locallyone login process for all clusters
PermissionsRoleBindings directly in the clusterRoles once in the identity federation, effective everywhere
Overviewkubectl and custom dashboards are sufficientState of all clusters side by side
Third-party clustersseparate toolchain per providerimported, in the same interface
RolloutHelm against one clusterSelection via labels, in stages
Effortnone — there is nothing extra to learnone more interface your team needs to know
Our recommendationyou are better off without RancherManaged Rancher, from three clusters

What to clarify before the first cluster

Seventeen questions from the first conversation about a cluster: costs, data location, commitment, operations and documents. The SLA and procurement documents are authoritative.

How much does Kubernetes hosting in Germany cost per month?

Kubernetes hosting in Germany at ENTRONYX CLOUD costs as much as its nodes, volumes and additional items in the catalogue: the example cluster of three ND3 nodes with 300 GB Block Storage NVMe and etcd backup costs €267.60 net per month in tier Standard; the control plane of this tier is not charged. In tier Highly available, it is €324.30.

You rent a Kubernetes cluster without a minimum term: with hourly billing, you pay by the second, up to the monthly amount, and billing ends when you delete the cluster. A commitment of 12 months reduces the net amount by 5%, and 24 months by 8%; all amounts are net amounts.

How much does a Managed Kubernetes cluster cost per month?

A cluster of three worker nodes ND3 (4 dedicated vCPU, 16 GB RAM each), 300 GB Block Storage NVMe and etcd backup costs €267.60 net per month in tier Standard, and €324.30 in tier Highly available.

The calculation in tier Standard: Three nodes ND3 at €77.60 each come to €232.80, three volumes at 100 GB each come to €25.80, the etcd backup for the cluster's state store costs €9.00; the control plane appears on the invoice at €0.00. In tier Highly available, the control plane costs €65.70; the etcd backup is included in the tier price there and is no longer a separate item.

With hourly billing, you pay by the second, up to a maximum of the monthly amount. You can calculate other sizes and quantities item by item in the calculator on this page; all amounts are net amounts.

Which items are added to the node price?

Added to this per month is what you book: in tier Standard the etcd backup (€9.00), each additional Load Balancer Layer 4 (€11.98), an outbound gateway for nodes without a public address (€39.98) and tier Highly available (€65.70) or Enterprise (€177.84); we charge by quantity for volumes, registry storage and traffic above the included volume. Per GB and month, volumes on Block Storage NVMe cost €0.0860 and the Private Registry €0.0070; each TB above the included volume costs €1.09.

Included at no extra charge are the tier Standard control plane, one Load Balancer Layer 4 and one public IPv4 address with a /64 IPv6 network per node; the Private Registry has no base fee. Data traffic is covered up to the included volume of the nodes; for ND3, this is 30 TB per month per node.

Only nodes without a public address need the outbound gateway for their outbound traffic — not to be confused with the gateway at the cluster entrance. The configurator shows further options such as larger Load Balancers or a different storage class with the amount before you order. All amounts are net amounts.

What does the control plane cost, and what is the difference between Standard and Highly available?

The control plane costs €0.00 in tier Standard and €65.70 net per month per cluster (€0.0900 per hour) in tier Highly available; in return, it runs across three fire zones there instead of one, with a committed API server availability of 99.99% instead of 99.9%. The worker nodes cost the same in every tier.

A fire zone is a structurally separate area of the location. The etcd backup is an option at an extra charge in tier Standard; from tier Highly available it is included in the tier price. Highly available also supports up to 500 instead of 100 worker nodes.

Tier Enterprise costs €177.84 net per month per cluster. It provides a dedicated control plane without third-party tenants, documented hardening according to the CIS benchmark and the BSI C5 attestation; up to 2,000 worker nodes are possible per cluster there.

Where is my data located, and can an authority from a third country access it?

Your cluster runs in a data centre in Germany, optionally in Frankfurt am Main or Düsseldorf; the operator of the platform is a company that is subject to German and European law, and there is no parent company or holding company in a third country, nor is there administrative access from there.

We check requests from authorities individually for legal basis, jurisdiction and proportionality; as far as legally permissible, we inform you before any disclosure.

The data processing agreement (DPA) according to Art. 28 GDPR is part of the main contract. The list of sub-processors states the country of domicile and processing purpose for each entry.

Can I try out a cluster by the hour without committing myself?

Yes, with hourly billing: a test cluster of three nodes ND3 in tier Standard costs €7.65 net for 24 hours, with a single node €2.55, and billing ends when the cluster is deleted. Billing is by the second; volumes and etcd backup are not included in the amounts.

The test cluster is an ordinary cluster in tier Standard and not a scaled-down offer: it has the same Kubernetes version, the same drivers and the same worker nodes as a cluster in production.

Is there a minimum term or a contract commitment?

No, not with hourly billing: you can delete the cluster at any time without notice, and billing ends with the deletion (Section 11 Terms and Conditions); a commitment of 12 or 24 months is voluntary and provides a 5% or 8% discount. Hourly billing is calculated by the second and capped at the monthly amount; if automatic scaling switches off nodes, they cost nothing from then on.

Without a commitment, the cluster continues to run monthly. Those who commit for 12 or 24 months pay the term in advance, with the first invoice, and receive a 5% or 8% discount on the entire monthly net amount — control plane, nodes, storage and network. During the commitment, the cluster can be scaled up at any time, but not scaled down. The commitment can be cancelled at the end of the term; for 12 months, it otherwise renews by 12 months.

With monthly billing, a fixed monthly amount applies: the capacity of all node groups remains reserved up to the upper limit and is charged even if nodes are switched off.

How do I migrate an existing cluster?

In four steps that you carry out yourself: first, create a new cluster, second, transfer the images to the Private Registry, third, point manifests or the GitOps source to the new cluster, fourth, transfer the volume data and change the DNS record. Both clusters run side by side until the new one carries the traffic. Versions 1.37, 1.36 and 1.35 can be selected for the new cluster; the GitOps source is the Git repository from which Argo CD or Flux sync.

The names of the StorageClasses (the storage profiles for volumes), the annotations of the previous Load Balancer and your Ingress objects need to be adjusted: these will continue to run as soon as they carry the Ingress class cilium; Cilium, the network plugin of the cluster, does not evaluate annotations from ingress-nginx.

During the transition period, Managed Rancher can manage the old cluster alongside the new one. The range that Rancher 2.15 manages applies to both: Kubernetes 1.34 to 1.36.

How do I get out again if I want to change providers?

Your manifests and Helm charts continue to run on any other compliant Kubernetes cluster once the platform-specific names and annotations have been adjusted; a full export of your data when changing providers is not charged separately and does not count towards the included traffic. The Kubernetes API remains unchanged, there is no proprietary interface in between; StorageClasses, Service types and annotations are ordinary Kubernetes objects.

Tied to the platform are the annotations for the Load Balancer, the names of the StorageClasses (the storage profiles for volumes), the class name cilium on Gateway and Ingress objects, and the Registry name in your image paths; policies of the CiliumNetworkPolicy type require Cilium as a network plugin. A manifest without our annotations will run unchanged; it will then receive the default settings of the Load Balancer.

You transfer the contents of persistent volumes yourself, as the etcd backup contains object definitions and no user data. Plan to use volume snapshots or your own backup for this.

What does the SLA cover: only the Kubernetes API or my application as well?

The commitment applies to the availability of your cluster's API server, not your application: 99.9% in tier Standard, 99.99% from tier Highly available. Worker nodes, Block Storage and Load Balancers have their own commitment of 99.95%.

Announced maintenance does not count as downtime, provided it was announced at least five calendar days in advance and does not exceed eight hours per calendar month and resource. Any time beyond this counts fully as downtime. Also excluded are, among other things, force majeure and errors in your own configuration.

If a month falls below the commitment, the SLA provides a service credit on the monthly base fee of the affected resource: depending on the achieved availability, between 10% and 100%. For the control plane in tier Standard, this base fee is €0.00. If our measurement shows the shortfall, we issue the service credit without a request; otherwise, you request it with the resource ID and the period of the incident — your own measurement data is not required. The authoritative version of the SLA is 4.2.

What is backed up, and what is not?

etcd, the cluster's state store containing all object definitions, is backed up — in tier Standard only with the booked option, from tier Highly available always; the content of your volumes is not included. You back up data in persistent volumes yourself using volume snapshots.

In tier Standard, the etcd backup is a bookable option: “Snapshots (7 days)” for €9.00 net per month. Without it, you are responsible for the backup yourself. From tier Highly available, the etcd backup is included in the tier price.

Every backup is a consistent snapshot and encrypted. A recovery replaces the state of the entire cluster and is therefore handled by support, not via self-service.

Who triggers upgrades, and what happens if my application uses a removed API?

You trigger the upgrade to the next minor version as long as your version is maintained; if the pre-check finds an object with a removed API version, the upgrade aborts and lists the affected objects. If your version is phased out without you having upgraded, we upgrade the control plane during an announced maintenance window.

Before every jump, the pre-check searches the entire object inventory of the cluster, not just your manifests in the repository. Updating the manifest remains your responsibility.

The control plane is upgraded first, followed by each node group on a rolling basis: a new node is added, an old one is drained and removed. PodDisruptionBudgets — the minimum number of running pods per application — are respected. Minor versions cannot be skipped, and downgrading the control plane is not possible.

Do I pay a surcharge if I continue to run an older Kubernetes version?

No, every version in the version table costs the same. You create new clusters in versions 1.37, 1.36 or 1.35.

The Kubernetes project maintains a minor version like 1.36 for around fourteen months. This is followed by a two-month transition period during which no new patches are provided from there; afterwards, we upgrade the control plane to the next minor version in an announced maintenance window. For 1.34, this means: patches until October 2026, upgrade from December 2026.

Does ingress-nginx run in the cluster, and how do I replace it?

No: the Kubernetes project retired the ingress-nginx Ingress controller on 24 March 2026, and we do not roll it out in new clusters; instead, you manage external traffic via the Gateway API, which is implemented by the Cilium network plugin. Since its retirement, ingress-nginx no longer receives security patches.

Existing Ingress objects continue to run as soon as they carry the cilium Ingress class; Cilium does not evaluate ingress-nginx annotations (nginx.ingress.kubernetes.io/…). The Ingress API itself remains in place.

For migrating your Ingress rules to the Gateway API, there is the ingress2gateway tool: it translates common annotations and reports what needs to be adjusted manually.

How do I contact support, and how quickly do they respond?

Via ticket: The price includes the SLA's basic support with an initial response time of 8 hours for critical incidents (P1), available Monday to Friday from 08:00 to 18:00. Clusters in tier Enterprise additionally have an escalation path around the clock. You also request a recovery from the etcd backup via ticket.

The SLA classifies the urgency of a case into four priorities, from P1 (production operations are completely down) to P4 (questions about usage). In addition to Basic support, the SLA includes three further support tiers; the highest responds to P1 in 15 minutes.

What documents do I receive for procurement and data protection?

The data processing agreement according to Art. 28 GDPR is part of every contract; the technical and organisational measures according to Art. 32 and the complete list of sub-processors are also documented, and the ISO/IEC 27001:2022 certificate and the BSI C5:2020 Type 2 attestation are available as evidence.

The certificate is valid until 30 November 2027 (recertification every three years); the attestation covers the audit period 1 July 2025 to 30 June 2026 (follow-up audit in progress). The scope of the attestation names Kubernetes as a service; in the tier table, the C5 attestation is listed for the Enterprise tier. The full C5 report is available only under a non-disclosure agreement.

There is no recognised certification under Art. 42 GDPR for the service. Responsibility under Art. 24 GDPR remains with you as the controller; we provide the infrastructure and the specified documents.

Are there GPU nodes in the cluster, and how much do the graphics cards cost?

Yes: you can choose from six card models up to the NVIDIA H200 SXM, each as a separate node group alongside your other nodes; the cheapest GPU size NG-RTX4000 (1 × NVIDIA RTX PRO 4000 Blackwell SFF, 24 GB graphics memory) costs €0.2932 per hour, capped at €214.00 net per month.

The device plugin is rolled out on these nodes and reports the cards to the cluster. Dynamic Resource Allocation, the device allocation via dedicated API objects, has been stable since Kubernetes 1.34; the allocation of the cards is handled here via the device plugin.

During operations, the autoscaler may scale such a group down to zero nodes; the configurator creates each group with at least one node. NG-RTX4000 is available for clusters in Frankfurt am Main and Düsseldorf.

Example, net/month€267.60$310.42

Configure cluster

Calculate first, then order

The configurator guides you through five steps from the control plane to billing and shows each item with its amount before you order. With hourly billing, you pay by the second, up to a maximum of the monthly price.

Example cluster per month
€267.60$310.42
The same, highly available
€324.30$376.19
Test cluster per day
€7.65$8.87
Locations in Germany
2