Elastic Node Pools
Use Elastic Node Pools to dynamically provision virtual worker nodes out of a large bare metal server pool, enabling efficient multi-cluster and multi-tenant environments on bare metal.
Use Case
- Large companies and MSPs run multiple Kubernetes clusters across teams and environments, but bare metal servers are too big to dedicate as worker nodes for each cluster
- Elastic Node Pools slice bare metal capacity into smaller, right-sized virtual workers that can be shared across clusters
- Elastic Node Pools leverage KubeVirt to dynamically create virtual worker nodes out of a large bare metal server pool:
Architecture
Three concepts work together to enable Elastic Node Pools:
| Concept | Persona | Description |
|---|---|---|
| Elastic Fleet | Provider | Turns a Machine Pool into virtualization capacity by deploying KubeVirt across its bare metal servers |
| Elastic Quota | Provider | Allocates a slice of Fleet resources (CPU, RAM, disk) to a consuming organization |
| Elastic Node Pool | Consumer | A pool of virtual Kubernetes worker nodes (Elastic Nodes), carved from a Quota and joined to a cluster |
Provider and Consumer
Elastic Node Pools introduce two personas:
- The Provider (e.g. a platform team) owns the bare metal infrastructure. They create Elastic Fleets from their Machine Pools and define Elastic Quotas to allocate capacity to consuming organizations. The Provider typically also runs its own cluster on the same infrastructure (e.g. for platform tooling).
- The Consumer (e.g. a product team or tenant) receives Elastic Quotas and creates Elastic Node Pools from them. Each Node Pool provides virtual worker nodes for one of the consumer's clusters.
This separation allows the provider to manage hardware centrally while consumers self-serve their own clusters and worker nodes within their allocated resources.
Elastic Fleet
An Elastic Fleet turns a Cluster's Machine Pool into a virtualization platform. When a Fleet is created, meltcloud deploys KubeVirt and the virtualization stack across the Machine Pool's bare metal servers. These servers can then host virtual machines alongside regular container workloads, including the Provider's own pods.
The Fleet's total capacity is determined by the resources of its underlying bare metal servers. As new machines are enrolled into the Machine Pool, the Fleet's capacity grows automatically.
Elastic Quota
An Elastic Quota allocates a portion of an Elastic Fleet's resources to a specific organization. Each Quota defines resource limits:
- CPU (cores)
- RAM (GB)
- Disk (GB)
A Fleet can have multiple Quotas, each for a different organization (or multiple Quotas for the same organization). The sum of all Quotas must not exceed the Fleet's total capacity.
Quotas are the mechanism that enables multi-tenancy: the provider controls how much capacity each consumer organization can use, while consumers are free to create Node Pools within their allocated limits.
Elastic Node Pool
An Elastic Node Pool is a set of virtual Kubernetes worker nodes that a consumer creates from an Elastic Quota. Each Node Pool specifies:
- Which Elastic Quota to draw resources from
- Which Cluster the virtual nodes should join as workers
- The node shape (CPU, RAM, disk per Elastic Node)
- The node count
The Node Pool's total resource consumption (node count × node shape) must fit within the Quota's remaining capacity. Each Elastic Node is a KubeVirt virtual machine running on the Fleet's bare metal servers that automatically joins the target cluster as a worker node. Elastic Nodes are spread across the available bare metal servers by the KubeVirt scheduler.