I Was Wrong About the Seven Nodes
A year later, the CPU and memory I thought every NKP cluster needed sit mostly in two default applications.

A year ago I wrote that you need two NKP instances: an Ultimate one for production and a Starter one for everything small. The reason I put first was size: how many nodes a cluster needs before it runs anything. An Ultimate cluster wanted seven nodes, four of them workers with eight vCPUs each, and that was too much for a development cluster or an edge site.
I have reread that post with the NKP guide open next to it, and on that first reason I was wrong. A small workload cluster does not need a second deployment: on the guide’s own numbers it can be created from the Ultimate management cluster. Everything below comes from those pages and none of it from a cluster, which matters in one place that I point out.
The Tables Describe a Default
The seven nodes are real. The guide gives three control plane nodes and four workers as the optimal nodes recommended for a Pro or Ultimate management cluster, and that is what the default settings deploy. For the clusters that the management cluster creates, the section has a different title: “Minimum Recommendation for Managed Clusters”. It asks for four workers with eight cores and 12 GiB each.
A note under that list explains the fourth worker. Four workers are needed to support upgrades of the Rook Ceph platform application, and with Rook Ceph disabled three are enough. In 2025 I read those rows as what every Ultimate cluster requires. The note says something narrower: the fourth worker is there for one application.
Where the Weight Sits
The same guide has a table of the workspace platform applications with their resource requests, and it marks the ones a cluster receives by default. Grouped, the default set looks like this.
| Deployed by default | CPU requests | Memory requests | Volumes |
|---|---|---|---|
| Prometheus stack and its adapter | 2.0 vCPU | 5.9 GiB | 100 GiB |
| Rook Ceph and its cluster | 2.6 vCPU | 8.1 GiB | 160 GiB |
| OpenCost and Kubernetes Dashboard | 0.1 vCPU | 0.25 GiB | 10 GiB |
| cert-manager, Gatekeeper, Reloader, Traefik and the auth proxies | 1.0 vCPU | 1.0 GiB | none |
| Total | 5.7 vCPU | 15.3 GiB | 270 GiB |
Prometheus and Rook Ceph account for four fifths of the CPU and nine tenths of the memory. The applications in the fourth row are also in the Starter workload column of the guide’s table of applications per license. The table still counts Kubernetes Dashboard among the defaults: on a new 2.19 installation Headlamp takes its place, and the guide gives no requests for it.
Now take the smallest managed cluster the guide describes for Starter: two workers with 3 vCPUs and 6 GiB each, a size it writes as non-default flags of the CLI (--worker-replicas 2 --worker-vcpus 3 --worker-memory 6). That is 6 vCPUs and 12 GiB before any workload arrives, and the default set asks for more memory than the two workers have. The guide documents the outcome in a note of its own: apply a Pro or Ultimate license to a Starter cluster with two workers, and the additional features fail for lack of resources.
The Selection Is Per Cluster
An application enabled in a workspace is deployed to every cluster of that workspace. The guide also lets you choose the clusters one by one, and it marks this as an Ultimate feature. To keep Prometheus and Rook Ceph off the small cluster it gives two routes.
From the UI
- On the Clusters page, open the small cluster.
- Go to its Applications tab and find the tile of the application.
- Open the menu on the tile and choose Disable.
The application leaves that cluster only, and the other clusters of the workspace keep it.
From the CLI
Each enabled application is an AppDeployment object in the namespace of the workspace, on the management cluster. With no clusterSelector, it goes to every cluster of the workspace. With a selector that names clusters, it goes only to those, so taking an application off a cluster means leaving that cluster out of the list.
kubectl get appdeployment -n ${WORKSPACE_NAMESPACE} kube-prometheus-stack -o yaml
spec:
clusterSelector:
matchExpressions:
- key: kommander.d2iq.io/cluster-name
operator: In
values:
- prod-cluster-1
- prod-cluster-2
# small-cluster-1 is not listed, so it does not receive the application
Edit that section and apply the object again. The same goes for four applications: kube-prometheus-stack, prometheus-adapter, rook-ceph-cluster and rook-ceph. For the last two the guide’s uninstall procedure removes the cluster before the operator, and I would keep that order here.
A cluster that joins a workspace receives every application enabled there, so the order of the steps matters. The default set is the one that asks for more memory than two small workers have. A workspace reserved for small clusters, with the heavy applications left out from the start, looks cleaner than removing them afterward.
The same AppDeployment also takes a configuration override per cluster, for shrinking an application where removing it is too much. None of this arrived with 2.19: the same pages are in the 2.18 guide, and the selector has been in the platform since DKP 2.4. It was there a year ago and I did not connect it to the size of a cluster.
On paper, a cluster left out of Prometheus and Rook Ceph carries about 1.1 vCPU and 1.3 GiB of platform requests. On the two small workers that leaves a little under 5 vCPUs and under 11 GiB for the workload. That is arithmetic on the requests the table lists, and it is the part I have not tested: whether a cluster that small behaves well under an Ultimate management cluster is a question for a lab.
What the Small Cluster Gives Up
Centralized metrics reach the management cluster through Thanos, which queries the Prometheus instance on each cluster, and centralized alerts come from each cluster’s Alertmanager. A cluster without the stack has nothing to query. The Prometheus adapter requires the stack and goes with it, and OpenCost lists the stack as an optional dependency.
Rook Ceph is the storage behind the logging stack, Velero and NKP Insights, as the same note on worker nodes says, and the chapter on Rook Ceph adds OpenCost and Harbor to that list. For a development cluster I would accept both losses. Neither loss is new to the comparison: the Starter cluster I recommended in 2025 has no Prometheus and no Rook Ceph either. For an edge site that runs production I would want the metrics back, and I would reach for the override before the exclusion.
What This Opens for an MSP
In February I described the opposite choice for a service provider: one self-managed Starter cluster per tenant, with no management cluster above them. Two of my reasons were the weight of the platform services and the upgrades tied to one timeline. On the tenant clusters the first is the one this article takes apart, while the management cluster keeps its seven nodes and pays for them once. The second was loosened in 2.19, which gave workload clusters an upgrade of their own.
With both weaker, one Ultimate management cluster for all tenants is worth a second look, because it can hold clusters of both sizes. A tenant cluster under it is a plain workload cluster. Kommander and Dex run once, on the management cluster. The guide’s Starter minimums show what that is worth: workers with 4 vCPUs and 8 GiB for a cluster that manages itself, 3 vCPUs and 6 GiB for a managed one.
The guide describes that model itself: one workspace per tenant, with one identity provider for all workspaces or a dedicated one per tenant with its own login page. A Starter instance does not have the NKP roles, and the cluster roles it offers apply to every cluster it manages. My February architecture came from running tenants and this is a reading, so I would not swap one for the other on paper. The size of a cluster no longer decides that choice.
What Is Left of the Second Instance
Two reasons I would still give, and neither is about size. The management cluster upgrades first, always: the guide asks for it before any workload cluster, ClusterClass or otherwise. Workload clusters can now be upgraded one at a time, and the management cluster has no such path. A second instance is still the only place to rehearse that step before production sees it.
The other is the license count. NKP licenses are counted on the vCPUs of worker nodes, so the workers of a small cluster count too. A second instance on AHV starts as Starter: NKP assigns it a default Starter key at creation, and that license is already active when the deployment finishes. Starter comes with AHV at no extra cost, so those workers add nothing to the Ultimate count.
That makes the second instance a choice. In 2025 I wrote it up as a requirement for anything small, and on paper it is an option with two arguments in its favor. The seven nodes were sized for a list of applications, and the list could be edited.