Unit 6.2: Provisioning a Public Cluster
Introduction
Unit 6.1 fixed the rules: a LoadBalancer service is a static IP on one node, nodes are replaced at every maintenance, and filtering lives in the cluster and at the edge. This unit turns them into FinCorp's public cluster fc-k8s-portal in fc-prod-fra-core.
The decisions that cannot be undone come first: node pool access, location, and each pool's template. The unit ends with the cluster built in the DCD and wired to the ALB fc-alb-edge from Unit 3.3.
1. Two Ways to Expose a Public Cluster
1.1 Direct Exposure on Reserved IPs
Public node pools give every node an external IP address. The simplest exposure is an ingress controller service of type LoadBalancer on an IP address reserved in IP Management. Reserving it outside Kubernetes keeps the address when the service is deleted, and a pre-reserved loadBalancerIP is what lets DNS records stay stable.
This option is cheap, but it inherits every property of Section 3.1 of Unit 6.1: one node carries the IP, up to 2 Gbit/s per node, client IPs lost unless externalTrafficPolicy: Local is set, and scaling by more IPs in DNS. To keep the client IP, run the ingress controller only on a labelled ingress node pool and annotate its service with cloud.ionos.com/node-selector, so that the IP lands on a node that runs the controller.
1.2 The ALB in Front
The managed alternative is the separately provisioned ALB. Manifests do not create it; you build it in the VDC and point its target group at the nodes. The node pools join the private LAN fc-app, where the ALB's backend already sits, and the ingress controller listens on a node port on every node. The ALB then terminates TLS, applies the host and path rules of Unit 3.3 and checks health, while the ingress controller routes inside the cluster.
| Option | Advantages | Disadvantages | Best for |
|---|---|---|---|
| Ingress controller as LoadBalancer on a reserved IP | No extra component; stable address | One node per IP; 2 Gbit/s per node; client IP needs externalTrafficPolicy: Local |
Internal tools, partner endpoints with modest traffic |
| ALB in front of the ingress controller | Managed TLS, Layer 7 rules, health checks, one edge for VMs and cluster | A target list to maintain as nodes are replaced | Customer-facing portals and APIs |
As shown above, the ALB is the choice for FinCorp's portal: it is the same edge that already serves fc-tg-portal and fc-tg-api, so the cluster becomes one more target group rather than a second internet entry point.
1.3 Storage for Stateful Pods
The CSI driver runs in the control plane, creates Block Storage volumes for Persistent Volume Claims (PVCs) and attaches them to nodes. Its provisioner name is cloud.ionos.com, and a storage class sets the volume type, the file system and the availability zone of the volumes it creates. Define storage classes with volumeBindingMode: WaitForFirstConsumer, which delays volume creation until a pod is scheduled, and give each zone's pool a class with the matching zone. Dynamically provisioned volumes are managed by the CSI driver: you cannot delete them yourself after the PV is deleted, and a Retain reclaim policy leaves them for manual cleanup.
DCD Implementation Walkthrough
You will create fc-k8s-portal with public node pools in Frankfurt, one Dedicated Core pool per zone on the fc-app LAN, and connect it to fc-alb-edge. This realises the ALB-in-front option of Section 1.2.
Prerequisites: the Create Kubernetes Clusters privilege (or the Administrator role); the VDC fc-prod-fra-core with the fc-app LAN (Unit 3.1); the ALB fc-alb-edge (Unit 3.3); an existing Object Storage bucket for audit logs, here fc-k8s-audit-fra (Unit 5.2); a reserved IPv4 address in Frankfurt for the node pool's Reserved IP address field, reserved under Menu > Network Services > IP Management.
Build goal: Build a public cluster end-to-end.
Steps (in the Data Center Designer):
- Go to Menu > Containers > Managed Kubernetes and select Create cluster. Enter the Name
fc-k8s-portaland select the Kubernetes version. Choose the latest stable version, which maximizes the time before the cluster reaches its end of life. - Under Location and network access, select Public as Node pool access and Frankfurt am Main (de/fra) as Location. Neither can be changed later, and node pool access cannot switch between public and private.
- Under Additional settings, turn on Audit logging and enter
fc-k8s-audit-fraas Target Object Storage bucket. In Allowed IPs, enter the address range from which FinCorp administers the cluster; an empty field allows API access from anywhere. Set the Maintenance window Day and Start time (UTC) to FinCorp's change window. - Select Create cluster. The status stays Deploying until the cluster is created; add node pools once it is Active.
- Select the cluster, open the Node pools tab and select Add node pool. Enter the Node pool name
fc-np-portal-z1, the Kubernetes version, the Virtual data centerfc-prod-fra-coreand the Reserved IP address. Under Node count, select Auto-scale with a Minimum of 2 and a Maximum within the 20-node recommendation. - Under Connection via private LAN, select the LAN
fc-appand keep DHCP on. Node pools can join private LANs only, and they take their LAN address through DHCP. - Under Node template, keep Server type Dedicated Core, select Cores and RAM (GB), set Availability zone to Zone 1, choose Performance as Storage type and set Storage size (GB). Apart from the server type, these settings cannot be changed after creation.
- Under Advanced settings, add the Label
nodepool=portaland set the pool's Maintenance window. Select Create node pool. Repeat steps 5 to 8 forfc-np-portal-z2in Zone 2. - Open the cluster's Security tab, select Visible to Groups and give
fc-prod-platform-opsthe Edit checkbox (Unit 2.2). - In the cluster list, open the OPTIONS column and select Download kubeconfig.yaml. Only administrators can retrieve the kubeconfig before a node pool exists.
- With
kubectl, apply the storage class below, then install the ingress controller with a service of type NodePort on the nodes labellednodepool=portal. - Go to Menu > Network Services > Target Groups and create
fc-tg-k8swith thefc-appaddresses of the nodes and the ingress node port, with Health Check Enabled. Onfc-alb-edge, add a Forward rule for the cluster's host or path tofc-tg-k8s, as in Unit 3.3.
The storage class carries the zone decision. Its parameters come from the CSI driver's documented example; the name and zone match FinCorp's first pool:
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
name: fc-performance-zone-1
provisioner: cloud.ionos.com
parameters:
type: Performance
fstype: ext4
availabilityZone: ZONE_1
volumeBindingMode: WaitForFirstConsumer
allowVolumeExpansion: true
Common mistakes:
- Expecting a
type: LoadBalancermanifest to create an ALB or NLB. It attaches a static IP to one node; the ALB is built separately. - Letting Kubernetes reserve the ingress IP. Without a pre-reserved
loadBalancerIP, the address is released when the service is deleted, and DNS breaks. - Treating the ALB target list as static. Maintenance replaces nodes one by one, so check the targets of
fc-tg-k8safter every maintenance, or automate their update. - Editing node servers, NICs or volumes in the Workspace. Resources managed by Kubernetes are shown read-only, and manual interaction while nodes are provisioned can cause undesirable results.
- Expecting one pool to cover two zones. The availability zone is part of the template; zone redundancy needs one pool per zone.
- Leaving Allowed IPs empty on a production cluster. The Kubernetes API is then reachable from anywhere.
- Installing an admission webhook tool such as Kyverno or OPA/Gatekeeper before the cluster has worker nodes. Its pods cannot schedule, which can deadlock node creation.
Summary
A public cluster is exposed either by an ingress controller on reserved IPs or by the ALB in front of it; FinCorp uses the ALB, so the cluster joins the existing edge as one target group. The build fixes the irreversible choices first, public access and de/fra, then adds one Dedicated Core pool per zone on fc-app, a zone-aware storage class and an API allowlist.
Key Points:
- Node pool access and location are fixed at cluster creation; a pool's template, apart from its server type, is fixed at pool creation.
- Reserve ingress IPs in IP Management, so that they survive the deletion of a service.
- The ALB is provisioned separately and targets the nodes on a shared private LAN through the ingress controller's node port.
- Use
WaitForFirstConsumerstorage classes with thecloud.ionos.comprovisioner, one per zone. - Set audit logging, Allowed IPs and the maintenance window at creation.