Kubernetes on bare metal runs cluster nodes directly on physical servers, without a hypervisor between Kubernetes and the hardware. It gives your team direct control of CPU, memory, storage, and network interfaces. It also leaves your team responsible for parts a cloud platform often supplies: a stable control plane address, external service IPs, persistent storage, and node replacement.
Before you order dedicated servers, answer four questions: How will the API stay reachable? How will users reach applications? Where will data live after a host fails? How will you restore the cluster? The answers shape the server count, network setup, and operating cost.
What are bare metal Kubernetes?
A bare metal Kubernetes node is a physical server running an operating system, a supported container runtime, and the Kubernetes node services. The control plane manages the cluster. Worker nodes run application Pods. A container network interface, or CNI, connects Pods across nodes.
“Bare metal” describes how Kubernetes uses the hardware. “Dedicated server” describes who has exclusive use of that server. You can rent a dedicated server and install Kubernetes on its OS to create a bare metal node. If you install a hypervisor first and run Kubernetes inside virtual machines, your Kubernetes nodes are VMs, even though you rent the entire physical machine.
An on-premises cluster sits in an organization’s own facility. A bare metal cluster can sit in a provider’s data center. Those terms describe different things.
What you gain and what you take on
| Keuze | Kubernetes on bare metal | Kubernetes in VMs | Managed Kubernetes |
|---|---|---|---|
| Hardwaretoegang | Direct access to the host and its devices | Access depends on the hypervisor and guest setup | Depends on the provider’s node types |
| capaciteitsveranderingen | Add or replace physical servers | Add VMs if host capacity exists | Add nodes through the provider’s service, within its limits |
| Control plane | Your team runs it, unless a separate service manages it | Your team may run it | Provider usually runs it |
| Load balancing and disks | Your team must choose compatible services | Depends on the hosting platform | Often supplied through platform integrations |
| Main operational cost | Hardware, network, storage, and staff time | Those costs plus a VM layer | Service charges plus the work your team still owns |
Bare metal suits teams with steady workloads, clear hardware needs, and people who can operate the cluster. Direct GPU access and sustained use of dedicated CPU or storage can be good reasons to test it. A managed service may fit better if the team needs rapid capacity changes or does not want to run the control plane. Neither setup is always faster or cheaper. Measure your own workload and account for hardware, transfer, support, software, spare capacity, and staff time.
A reference architecture for a production cluster
A production design should keep the Kubernetes API reachable, give applications enough capacity after a node loss, and make data recovery possible. Here is an example starting point, not a fixed minimum for every application:
| Part | Example design | What it solves |
|---|---|---|
| Control plane | Three physical nodes with one etcd member on each | One failed member leaves a two-member majority |
| API endpoint | A stable address that can reach healthy API servers | Workers and administrators retain a route to the control plane |
| Workers | Two or more physical nodes, sized for the workload | Pods have a place to run outside the control plane |
| Hostnetwerk | Defined private paths for node traffic, with firewall rules | Nodes can reach required cluster services |
| Pod network | One CNI chosen for the cluster’s routing and policy needs | Pods can communicate across hosts |
| External traffic | A service IP plan and an ingress or Gateway implementation where needed | Clients can reach the applications |
| Opslag | A selected local, shared, or replicated storage design | Stateful Pods have defined failure behavior |
| Herstel | Off-cluster etcd snapshots and application data backups | The team can rebuild after a broader failure |
Three physical servers can run both control plane components and application workloads if the chosen distribution permits it and you reserve capacity for both. Separate workers make capacity and maintenance easier to reason about. A three-node lab may be useful, but do not call it highly available until you have tested the API, application, storage, and network paths during a host failure.
A drawing with three boxes also misses shared infrastructure. If all three servers depend on one switch, power feed, rack, or site, that shared component can interrupt the whole cluster. Ask the provider what physical separation it can supply. Do not spread etcd across distant sites without checking network latency and the effect of a link failure.
Control plane, etcd quorum, and the API address
The Kubernetes API server accepts changes to cluster state, while etcd stores that state. In a common kubeadm design, each of three control plane servers runs an etcd member. Two members form a majority after one member fails. With two etcd members, losing one leaves no majority.
A majority alone does not keep the API reachable. The address used by administrators and workers must still lead to a healthy API server. For a kubeadm high availability setup, the configured controlPlaneEndpoint must match a working load balancer address. Plan that address before creating the cluster. Place its availability outside the fate of any one application worker.
There are two common etcd layouts. Stacked etcd places etcd beside control plane components on the same nodes and keeps the hardware count smaller. External etcd runs etcd on separate nodes and adds machines and operational work. Choose on failure isolation, support, and staffing needs. Neither option removes the need for snapshots.
If etcd loses its majority, existing application processes may continue to run for a time, but the control plane cannot reliably update cluster state or schedule replacement Pods. Recovery is an operations procedure, not a reason to skip backups.
Worker count and the N-1 test
Size worker capacity for the loss of a node, not only for a normal day. Start with actual application CPU and memory requests. Add space for the OS, kubelet, CNI, storage agents, logging, and other DaemonSets. Then check whether replicas can be placed on distinct failure domains.
Consider an illustrative cluster of three workers. After system reservations, assume each has room for 24 CPU request units. Your application Pods request 45 units in total. Normally the cluster has 72 units. After one worker fails, it has 48. On CPU requests alone, the remaining nodes have three units to spare. That is a narrow margin. Memory limits, per-node placement rules, local disks, and traffic may still stop the Pods from returning to service.
This is a capacity method, not a benchmark or a suggested CPU size. Repeat it with your own requests and observed peaks. Use topology spread rules or placement rules where needed so replicas do not all land on one server.
Networking: separate four different paths
Bare metal Kubernetes networking starts with the physical network. Kubernetes cannot fix an IP routing or firewall rule that prevents the hosts from reaching each other. Draw the paths before selecting a CNI or a load balancer:
- Host network: Physical interfaces, private links, VLANs, routes, DNS, and firewalls connect servers.
- Pod network: A CNI gives Pods addresses and a way to communicate across nodes.
- Control plane endpoint: A stable address takes API traffic to healthy control plane nodes.
- Application entry: A service IP and, for HTTP applications, an ingress controller or Gateway implementation take client traffic to Pods.
Pod and Service address ranges must not overlap with host, private network, or provider-routed address ranges. Check the CNI’s requirements for MTU, encapsulation, routing, and NetworkPolicy. An overlay that adds packet headers may need a smaller Pod network MTU than the physical interface. A packet-size issue may show up as intermittent timeouts rather than a complete network failure.
Use the Kubernetes ports and protocols reference when writing firewall rules. Allow only the paths your chosen components need. Keep the Kubernetes API and out-of-band server management off unrestricted public access.
An API endpoint is not an application load balancer
These three terms describe separate jobs:
| Bestanddeel | hoofdtaak | vraag om te stellen |
|---|---|---|
| API endpoint | Reach a healthy Kubernetes API server | Does it work before cluster add-ons start and after a control plane node fails? |
| Service of type LoadBalancer | Give an application a reachable service IP | Who assigns and announces that IP on this network? |
| Ingress controller or Gateway implementation | Route application traffic by host, path, or other supported rules | How does traffic reach that controller in the first place? |
A Kubernetes LoadBalancer Service needs an implementation. Without one, the service may wait for an external address. Installing an ingress controller does not, on its own, provide that address. MetalLB can provide application service IPs on suitable networks, but it depends on a running cluster. Do not assume that adding MetalLB also solves the first bootstrap of a stable API endpoint.
MetalLB L2 or BGP?
MetalLB can announce service addresses in layer 2 mode or through BGP. The right option depends on what the host network and provider allow.
| Methode | Network requirement | Main tradeoff |
|---|---|---|
| laag 2 | Nodes and gateway must support the required local address discovery for the chosen IPs | One node receives incoming traffic for a given service IP; a failover may pause traffic while neighbor caches update |
| bgp | Approved routing sessions with suitable routers and address policy | Routes can bring traffic to multiple nodes, but routing setup and failure handling need more care |
| Provider or external load balancer | A supported upstream service or routed IP arrangement | The provider’s features and support terms set the available design |
Do not take a block of assigned public IPs and assume it is an L2 MetalLB pool. A provider may route those IPs to one server or forbid the required address announcements. Ask whether the intended service IPs can move between hosts, whether the servers share the needed layer 2 segment, and whether BGP peering is available for the chosen plan. If the answer is no, use a supported routed or external load-balancer design.
For high traffic, note the layer 2 limit: a single node receives incoming packets for each service IP before Kubernetes sends traffic onward to Pods. A 10 Gbps server port does not make a single service flow run at 10 Gbps, and a port rating does not state the included monthly data transfer.
Storage: where does the data go when a host fails?
Kubernetes can start a replacement Pod, but it cannot make lost local bytes appear on a different server. Choose the data model before placing a database or file service in the cluster.
| Opslag keuze | Past goed | Host failure behavior | Work your team owns |
|---|---|---|---|
| Local SSD or NVMe PersistentVolume | Workloads that can rebuild data, or applications that manage their own replication | The volume stays tied to its host; a Pod elsewhere cannot use those bytes automatically | Disk health, restore, and application replication |
| External shared storage through a supported CSI driver | Workloads that need a volume available to another node | Depends on the storage system, network, access mode, and driver | Shared storage availability, access control, backups |
| Software-replicated storage across nodes | Workloads whose data can tolerate the chosen replication cost and failure model | A replica may serve data after a node fails if health and placement were sound | Storage nodes, network capacity, quorum, recovery, backups |
A local PV includes node placement rules so Kubernetes schedules its consumer where the volume exists. The WaitForFirstConsumer binding mode lets scheduling consider the Pod’s placement before it binds the volume. It does not copy the data or make local storage available on another machine. A failed database host can therefore leave its replacement Pod waiting until you repair the host or restore data using the application’s recovery plan.
Software replication also consumes network and disk resources. If storage replicas and application replicas all sit on one physical host or one rack, the expected failure protection may not exist. For a database with its own replication, compare application-managed replicas with a storage layer before running both. Either choice still needs backups.
Two backups, two different jobs
Een etcd snapshot records Kubernetes cluster state, such as object definitions and configuration. It is not a copy of the contents of your usual database PVC. An application data backup records the data your workload must restore. Use a method suited to the database or file system, and check consistency during a restore.
Store recovery material outside the failed cluster, protect access to it, and keep the keys or credentials required to read it. A useful recovery test rebuilds the control plane in an isolated environment, restores the needed cluster state, then restores application data and checks the application. Record the time it took and how much data was missing. Those observations give you a measured recovery time objective, or RTO, and recovery point objective, or RPO. A backup schedule alone cannot prove either target.
RAID can keep a server running after some disk failures when configured for redundancy. It does not restore deleted files, repair bad application writes, or replace an off-cluster backup.
Common pitfalls and first checks
| Symptoom | Mogelijke oorzaak | First check and next action |
|---|---|---|
| Een LoadBalancer Service has no external IP | No service IP implementation or address pool | Check the service events, controller health, and approved IP pool. Confirm upstream routing before assigning addresses. |
| Pods on different hosts cannot communicate | CNI, firewall, route, or MTU issue | Check Pod IPs, node routes, CNI logs, and a cross-node packet test. Change one layer at a time. |
| kubectl stops working after one control plane failure | The API endpoint lived on one server or routes did not fail over | Test the endpoint from a worker and a separate admin host. Check healthy API backends and the VIP owner. |
| A database Pod stays Pending after a worker fails | Local PV is tied to the lost host or no suitable volume exists | Inspect the PVC, PV node placement rules, Pod events, and restore plan. Do not force a volume onto a different host without its data. |
| Maintenance drain never finishes | A PodDisruptionBudget or workload placement rule blocks eviction | Inspect the budget and available replicas. Add capacity or fix the application before changing protection rules. |
| Replacement Pods will not schedule | No remaining CPU, memory, node placement rules match, or suitable storage | Check scheduler events and repeat the N-1 calculation for every scarce resource. |
| Service IP responds only from some networks | Address announcement or upstream neighbor cache issue | Check the actual route, ARP or NDP behavior, and provider network design. |
These are starting points, not proof of a single cause. Record symptoms and component logs before changing routing or storage settings.
A PodDisruptionBudget helps control voluntary eviction, such as a planned node drain. It cannot stop a power failure or make a failed node’s local disk available elsewhere. Run both planned and unplanned failure tests.
How to deploy in the right order
- Set service and recovery goals. List acceptable downtime, data loss, expected traffic, and who is on call. Decide whether the cluster is a lab or production service.
- Confirm physical resources. Choose server roles, CPU, memory, disks, private network, management access, address pools, and failure domains. Ask how quickly a failed server can be replaced.
- Choose a supported software set. Pick an OS, Kubernetes distribution, container runtime, CNI, and storage driver whose versions work together. With kubeadm, check current container runtime and cgroup guidance before configuring hosts.
- Provide the API endpoint and build the control plane. Confirm that the endpoint reaches healthy servers. Select stacked or external etcd, then take a first snapshot.
- Install and test the Pod network. Join workers, verify cluster DNS, and test Pod traffic across hosts. Confirm firewalls and MTU before adding user traffic.
- Add service exposure and storage. Test a Service IP from outside the cluster, then create a test PVC and confirm its placement and failure behavior.
- Deploy a sample workload and rehearse failures. Test a planned drain, sudden node loss, control plane loss, service IP movement, and data restoration. Write down what worked and what needs to change.
A one-server cluster is fine for learning. It is one physical failure domain. A two-server installation can teach you about joining nodes, but two stacked etcd members do not tolerate the loss of either member. For production, follow the supported topology and test the service’s actual recovery, not just the cluster’s node count.
Recovery tests to run before production traffic
Use a worksheet that separates the expected result from what you observe. Keep evidence such as timestamps, health checks, and restore logs.
| Test | What to do in a safe test window | What a passing result looks like |
|---|---|---|
| Planned worker maintenance | Drain one worker under the current disruption rules | Required application replicas keep serving; workloads move or the drain stops for a documented reason |
| Sudden worker loss | Isolate or shut down a test worker | Services remain usable within your target; spare nodes accept Pods that do not depend on lost local data |
| One control plane loss | Stop one control plane host | The stable API address still reaches a healthy API server and etcd retains a majority |
| Service IP failover | Stop the announcing node in a test service | Clients reach the same service IP again within the measured recovery window |
| Storage host loss | Remove one storage node or local-volume host from a test workload | Data behavior matches the selected storage design; the recovery steps work |
| Backup restore | Restore etcd and application data in a separate test environment | Cluster objects and application records pass integrity checks |
Use actual measured times in your incident plan. If an unplanned failure takes longer than the application can accept, change the design or recovery target before launch. Re-run these checks after network changes, storage changes, and major cluster upgrades.
What to ask a dedicated server provider
The network contract matters as much as the hardware quote. Send a provider the intended topology and ask for written answers to these points:
- Can the servers use a private network, and is it the same local network segment or routed between sites?
- Can a service IP move between servers? Are layer 2 address announcements or BGP sessions supported for our plan?
- Which public IPs can we use for application services, and how are they routed?
- Can you place control plane nodes across distinct racks, power paths, or facilities? What separation can you confirm?
- What are the CPU, RAM, disk, network port, and included transfer terms for each node?
- What out-of-band console or KVM access is available if the OS or network fails?
- How are failed disks and servers replaced, and who performs the replacement?
- Which tasks belong to the provider and which belong to us: host OS, Kubernetes, CNI, service IPs, storage, backups, and restore?
Atal Networks vermeldt bare metal servers en Toegewijde serveropties with physical resource control and multiple network choices. We should confirm the private network topology, IP routing, management access, and support terms for the exact servers and location you select. A dedicated server purchase does not by itself include a managed Kubernetes control plane or application data recovery.
Veel gestelde vragen
Can Kubernetes run on one dedicated server?
Yes. One dedicated server can run a learning cluster, and some applications accept a single-node deployment. If that host fails or needs maintenance, its control plane and local workloads may stop together. Use the single-node setup only when that service risk fits your needs.
Are three physical servers enough for high availability?
Three control plane servers can keep etcd’s majority after one member fails. They do not guarantee application availability. Check the API endpoint, worker capacity, replica placement, storage, and any shared switch or power path. A recovery test is the way to learn whether the whole service survives one host loss.
Does MetalLB replace the control plane load balancer?
Do not assume so. MetalLB supplies IP addresses and announcements for Kubernetes Services after the relevant cluster components run. A stable API endpoint must be designed for cluster bootstrap and control plane failures. You may use another supported VIP or external load-balancing method for that endpoint.
Do I need BGP for Kubernetes on bare metal?
No. BGP is one option for announcing service IP routes. MetalLB layer 2 mode can work where the network supports the required address discovery. A provider load balancer or routed IP design may also fit. Ask the host which methods it supports before choosing service address ranges.
Can a Pod with local NVMe storage move to another server?
A replacement Pod can be scheduled elsewhere only if its storage needs can be met there. A Kubernetes local PersistentVolume points to data on a particular node. Moving the Pod alone does not move that data. Use application replication, a suitable shared or replicated storage system, or a restore procedure.
Is bare metal Kubernetes always faster than Kubernetes in VMs?
No. Removing a hypervisor can help workloads that need direct hardware access, but performance also depends on CPU placement, storage, network design, and the application. Compare representative workloads under the same settings. A general performance percentage from another environment does not predict your result.
What should I back up besides etcd?
Back up application data, database state, needed secrets or recovery keys, and the configuration required to rebuild cluster add-ons and external infrastructure. An etcd snapshot covers cluster state, but it does not replace a database backup. Test that you can restore both in a separate environment.
What happens when a bare metal worker fails?
Kubernetes can place replacement Pods on healthy workers if the control plane can act and those workers have capacity and suitable storage. Existing local volumes stay with the failed node. A good failure plan includes spare capacity, replica placement, storage recovery, and a server replacement procedure.
How much private network capacity does a cluster need?
There is no universal number. Measure traffic between Pods, storage replicas, backup systems, and clients. Size for peaks and for the extra traffic a node failure creates. Verify the port speed, network path, included transfer, and any limits in the provider’s plan; they are different measures.
