Unit 6.3: Provisioning a Private Cluster
Introduction
FinCorp's retrieval and inference workers handle customer documents, so their nodes must not be reachable from the internet. A cluster with private node pools gives exactly that, but it changes three things that Unit 6.2 relied on: no public node addresses, no LoadBalancer services, and an outbound path that the service builds for you.
This unit explains those differences and builds fc-k8s-ai in fc-prod-fra-ai. Steps that work as in Unit 6.2 are referenced, not repeated.
1. What "Private" Means
1.1 The Data Plane Is Private; the API Is Not
In a cluster with private node pools, nodes have only internal IP addresses, so nodes and pods are isolated from the internet. The node pools sit in a private network behind a NAT Gateway, which allows connections from the nodes to the internet but not the other way round. Traffic between the nodes stays inside the private network.
The control plane is still exposed to the internet. Protect it with Allowed IPs, which restricts API access to an IP address range. FinCorp enters the range of its administration network and its deployment pipeline, so that a leaked kubeconfig cannot reach the API from any other network.
Two features of public pools are not available. Kubernetes services of type LoadBalancer are not supported, and static node IP addresses are not supported. Inbound traffic to a private cluster therefore comes from inside your network, for example from VMs or load balancers on a private LAN that the node pool also joins.
1.2 One Prerequisite, Two Resources the Service Deploys
The cluster needs one thing from you before it exists: a reserved IPv4 address, not in use by any other resource, which becomes the NAT gateway IP address. The service then deploys two network resources itself:
| Resource | Deployed by | Purpose |
|---|---|---|
| NAT Gateway | Managed Kubernetes, on the reserved NAT gateway IP address | Outbound traffic between the cluster nodes and the control plane, for example to retrieve container images |
| Private Cross Connect | Managed Kubernetes, in your VDC | Node-to-node communication across all node pools of the cluster, including pools in different VDCs |
As shown above, both resources exist to serve the cluster. This NAT Gateway is not intended for arbitrary nodes, so you cannot attach an additional private network to it; your VMs keep using their own NAT Gateway (Unit 3.6). Resources managed by Kubernetes are shown read-only in the DCD.
The NAT gateway address is also the cluster's public source address. Partners or services that allowlist FinCorp, such as an external API, see the nodes' outbound traffic from that one address.
1.3 The Node Subnet and the Fixed Settings
You can define a node subnet for the private LAN, which must have a prefix length of /16; otherwise a default range is assigned. The subnet must not intersect the cluster's networks for pods and services. For clusters created with Kubernetes 1.30 and above, those are 100.96.0.0/12 and 100.64.0.0/18. It should also stay clear of every range that FinCorp routes, because the address plan of Unit 3.1 spans the VDCs on a Cross Connect.
Once provisioned, the region, the NAT gateway IP address and the node subnet cannot be changed, and node pool access cannot be switched between private and public. A cluster for private node pools is bound to one region: its node pools must be in VDCs in the same location as the cluster, and the control plane runs in that region. For FinCorp that is de/fra, which keeps the Kubernetes API, its secrets and its audit trail in Germany (Unit 6.1, Section 4).
DCD Implementation Walkthrough
You will reserve the NAT gateway address, then create fc-k8s-ai with private node pools in fc-prod-fra-ai. The node pool fields follow Unit 6.2; only the private differences are described in full.
Prerequisites: the Create Kubernetes Clusters privilege; the VDC fc-prod-fra-ai in the same location as the cluster; the audit bucket fc-k8s-audit-fra (Unit 6.2); a free /16 range in FinCorp's address plan, here 10.30.0.0/16.
Build goal: Build the private variant reusing the public-cluster patterns, networking first.
Steps (in the Data Center Designer):
- Go to Menu > Network Services > IP Management and select + Reserve IP Blocks. Enter the Name
fc-k8s-ai-nat, Number of IPs1and the Frankfurt Region, and confirm. Do not assign this address to anything else. - Go to Menu > Containers > Managed Kubernetes, select Create cluster, and enter the Name
fc-k8s-aiand the Kubernetes version. - Under Location and network access, select Private as Node pool access and Frankfurt am Main (de/fra) as Location. In NAT gateway IP address, select
fc-k8s-ai-nat. In Node subnet, enter10.30.0.0/16. - Under Additional settings, turn on Audit logging with the bucket
fc-k8s-audit-fra, enter FinCorp's administration and pipeline range in Allowed IPs, and set the Maintenance window. Select Create cluster and wait for the status Active. - Add node pools as in Unit 6.2, steps 5 to 8, with these values: Virtual data center
fc-prod-fra-ai, namesfc-np-ai-z1andfc-np-ai-z2, a new private LANfc-ai-appunder Connection via private LAN, and Dedicated Core templates in Zone 1 and Zone 2. - If pods must reach services in
fc-prod-fra-core, select Attach another private LAN and add the AI VDC's LAN on the Cross Connect of Unit 3.6. Keep its DHCP range separate from the other VDCs on that Cross Connect. - Open the cluster's Security tab, select Visible to Groups, and give
fc-prod-platform-opsEdit. - In Kubernetes Manager, select the cluster, open the Cluster Settings tab and download kubeconfig.yaml. Run
kubectlfrom a host inside the Allowed IPs range. - Open
fc-prod-fra-aiin the Workspace and confirm that the managed resources of the cluster are present. Leave them unchanged.
Common mistakes:
- Creating the cluster before reserving the NAT gateway IP address, or selecting an address that another resource uses.
- Assuming "private" hides the Kubernetes API. It stays internet-facing; set Allowed IPs at creation.
- Choosing a node subnet that overlaps
100.96.0.0/12,100.64.0.0/18, or a FinCorp range on a VPN or Cross Connect. The subnet cannot be changed later. - Writing a
type: LoadBalancerservice for a private cluster. It is not supported; expose services to internal clients through a private LAN that the node pool joins. - Attaching other servers or networks to the cluster's NAT Gateway, or editing the Private Cross Connect. Both belong to the service.
- Placing a node pool in a VDC in another location. Private node pools must be in the cluster's region.
Summary
A private cluster isolates the data plane, not the API. You reserve one IPv4 address for the NAT gateway and choose a non-overlapping /16 node subnet before you create it; the service then deploys a NAT Gateway for outbound traffic and a Private Cross Connect for traffic between node pools. Region, NAT address, node subnet and access type are fixed at creation, so FinCorp settles all four in the address plan before the first click.
Key Points:
- Private node pools have internal IPs only and reach the internet outbound through the service's NAT Gateway.
- The Kubernetes API remains internet-facing; restrict it with Allowed IPs.
- LoadBalancer services and static node IPs are not supported on private node pools.
- The node subnet is a /16 that must not intersect
100.96.0.0/12or100.64.0.0/18(Kubernetes 1.30 and above). - Region, NAT gateway IP address, node subnet and node pool access cannot be changed after provisioning.