Master Supervisor cluster deployment, TKG cluster lifecycle, networking, storage, and security for Kubernetes workloads on vSphere. Covers Tanzu Kubernetes Grid, persistent volumes, NSX integration, and production Day-2 operations.
3V0-24.25
VCAP
60
Questions
135m
Duration
300 (scaled score; Broadcom publishes no percentage or ceiling)
Pass Score
32
Objectives
Exam Blueprint Weights
Section titles, groupings and weights below are VCDX Academy study groupings, NOT the official Broadcom blueprint structure. Broadcom publishes no section weights. Always cross-check the official exam guide. Official exam guide ↗
Section 1 — Architecture
~15%
Section 2 — Cluster Lifecycle
~25%High Weight
Section 3 — Networking
~20%
Section 4 — Storage
~15%
Section 5 — Security and Operations
~25%High Weight
Version Evolution
vSphere Kubernetes Service (VKS) is the VCF 9.0 name for the Supervisor-based Kubernetes platform formerly delivered as vSphere with Tanzu / Tanzu Kubernetes Grid Service. Evolution: VCF 4.0 (vSphere 7) introduced Workload Management with the Supervisor and TKG Service clusters; VCF 5.x moved cluster provisioning to Cluster API with ClusterClass (TKC API retained alongside); VCF 9.0 ships VKS 3.3.1 with the v1beta1 Cluster API and built-in ClusterClass as the standard, NSX VPC networking for the Supervisor, VKr 1.28–1.32 images, Foundation Load Balancer for VDS Supervisors, the VCF CLI, and deprecates HAProxy, the TKC API, the Velero operator install and the SupervisorServiceDefinition package.
Learning Outcomes
Describe the VCF 9.0 Supervisor topology (control plane VM count and sizes, Management Zones, Spherelet, Supervisor Services, vSphere Namespaces, Regions and Zones) and the networking stacks (NSX VPC, NSX segments, VDS with Foundation Load Balancer or Avi)
Plan and validate Supervisor activation against the 9.0 minimum requirements (hosts, vCenter, NSX Manager, Edge cluster, networks, MTU, content library)
Provision, scale, autoscale and upgrade VKS clusters with the v1beta1 Cluster API and built-in ClusterClass, VKr versions and standard packages via the VCF CLI
Protect clusters with the Velero standard package (Schedule objects, Kopia) and explain what Velero does and does not back up
Design multi-tenant isolation across namespaces, NSX VPC, Antrea/NSX policies, Pod Security Admission, RBAC and identity providers, and troubleshoot activation and provisioning failures from the object chain
vSphere Kubernetes Service (VKS) is the Kubernetes layer of VCF 9.0: the vSphere Supervisor turns a vSphere cluster (or three clusters as Management Zones) into a Kubernetes control plane, and VKS clusters (Cluster API, built-in ClusterClass) are the conformant workload clusters it provisions. VCF Automation All Apps organizations consume Supervisors through Regions, Zones and vSphere Namespaces.
Supervisor topology (VCF 9.0.1 — Requirements for Supervisor Deployment with VPC Networking; Change the Control Plane Size)
Element
What it is
Control plane VMs
One VM (single Management Zone, the default when the Supervisor is activated during workload-domain creation) or three VMs (three Management Zones / HA). Sizes: Tiny 2 CPU / 8 GB, Small 4 CPU / 16 GB (default), Medium 8 CPU / 16 GB, Large 16 CPU / 32 GB, 32 GB disk each; the size can only be scaled up. The minimum-requirements table lists 4 CPU / 16 GB per control plane VM.
ESX hosts
Members of the Supervisor's cluster(s); Spherelet runs on each host so it can run vSphere Pods and host VKS cluster node VMs. vSphere DRS (Fully Automated) and vSphere HA must be enabled.
Supervisor services
Kubernetes operators installed and managed per Supervisor. The Velero vSphere Operator is a core Supervisor Service: it comes pre-registered with vCenter but is installed on each Supervisor as a separate step (Supervisor Management > Services). Further Supervisor Services (Harbor, external-dns, Contour and others) are added from the service catalog.
vSphere Namespaces
Logical pools of CPU, memory and storage from one to three Zones; created per project from Namespace Classes; carry storage classes, VM classes, content libraries and quotas.
Regions and Zones
A Region is a set of Supervisors sharing an NSX Local Manager; Zones are vSphere clusters supplying compute; the provider assigns them to organizations through Region Quotas.
Networking stacks for the Supervisor (VCF 9.0 — Supervisor networking; Deprecation Announcements)
Stack
Load balancing
Notes
VCF Networking with NSX VPC
NSX load balancer (and Avi where configured)
Default when the Supervisor is activated from VCF Operations; per-namespace VPC multi-tenancy; required to unlock the full 9.0 capability set; VKS 3.3.1 or later for VPC networks
NSX Tier-0 / Tier-1 segments
NSX load balancer
The pre-9.0 NSX model; still supported
VDS networking
Foundation Load Balancer (bundled with vCenter, Layer 4, VLAN-backed topologies, VDS only) or Avi Load Balancer
HAProxy is deprecated in VCF 9.0 (to be removed in a future major release)
vSphere Pods are only supported with NSX-based networking.
Node images are VKr (VMware Kubernetes release) images delivered through a subscribed or local content library; the TKR name belongs to the Tanzu era.
VKS 3.3.1 on VCF 9.0 adds VKr 1.32 and drops VKr 1.27.x (and 1.31.1, adding 1.31.4); to upgrade to VKS 3.3.0 or later, every cluster must already run VKr 1.28 or later. Later VKS releases raise the floor again (see the VCF 9.0 → 9.1 delta section for VKS 3.6).
A VKS cluster pins its release in spec.topology.version (for example v1.32.0---vmware.6-fips-vkr.2); upgrades change that field.
Key design facts
Supervisor and VKS cluster are different constructs: workloads run in VKS clusters (VMs) or as vSphere Pods on the Supervisor; neither runs 'on TKG worker nodes by default'.
The Supervisor control plane is HA with three VMs across three hosts (or three Zones); one VM means a single point of failure and vSphere HA restart as the recovery.
Isolation layers available to a design: vSphere Namespace (quota, RBAC, storage and VM classes), NSX VPC per namespace (network), Antrea NetworkPolicy / ClusterNetworkPolicy inside clusters, Pod Security Admission, and separate Supervisors or Zones for hard tenancy.
Key Takeaways
Supervisor control plane: 1 or 3 VMs sized Tiny/Small/Medium/Large (2/4/8/16 CPU; 8/16/16/32 GB; Small default; scale-up only), DRS Fully Automated and HA required; Spherelet on every ESX host.
Networking choices in 9.0: NSX VPC (default from VCF Operations, full capability set), NSX Tier-0/Tier-1 segments, or VDS with Foundation Load Balancer (L4, VLAN) or Avi; HAProxy is deprecated; vSphere Pods need NSX.
Images are VKr (not TKR): VKS 3.3.1 supports VKr 1.28–1.32 on VCF 9.0; a VKS cluster pins its release in spec.topology.version and upgrades by changing it.
Supervisor activation in VCF 9.0 happens from VCF Operations during workload-domain creation (optional step, VCF Networking with VPC by default) or later from the vSphere Client (Workload Management).
Prerequisites (VCF 9.0.1 — Requirements for Supervisor Deployment with VPC Networking)
Item
Requirement
vSphere clusters
1 or 3 clusters (three for three Management Zones); DRS Fully Automated and HA enabled on each
ESX hosts per cluster
Without vSAN: 1 host (3 recommended); with vSAN: 3 hosts (4 recommended); each host 8 CPU and 64 GB RAM; host names in lower case
vCenter 9.0
Small or larger (2 CPU / 21 GB / 290 GB minimum)
NSX Manager
Medium (6 CPU / 24 GB / 300 GB)
NSX Edge cluster
Two Large nodes (8 CPU / 32 GB / 200 GB) in Active/Standby for load balancing and NAT
Control plane VMs
1 (single Zone) or 3 (three Zones); 4 CPU / 16 GB / 16 GB each at minimum size
Networks
ESX TEP network; Edge TEP network (may share the ESX TEP VLAN); Tier-0 uplink network and a block of 5 uplink IPs; TEP MTU greater than 1600; management network for the control plane VMs (default ESX management network or a dedicated port group / VPC subnet); no IPv6 clusters with a 9.0 Supervisor
Storage
Storage policies for control plane VMs, ephemeral disks and image cache; vSAN optional
Content library
Subscribed (internet) or local (air-gapped) library holding the VKr images
Activation flow (VPC networking)
Deploy the NSX Edge cluster and set up the Tier-0 connectivity in the workload domain; create the VPC constructs in vCenter.
If not using the default ESX management network, configure the port groups or VPC subnets for the Supervisor management network.
Configure the Centralized Gateway.
Optionally deploy and configure Avi Load Balancer.
Activate the Supervisor (from VCF Operations at domain creation, or Workload Management in the vSphere Client): choose single or three Zones, control plane size, management network, storage policies and the content library.
Create vSphere Namespaces (or let VCF Automation create them from Namespace Classes), assign users/groups, storage classes, VM classes and quotas.
Alternative stacks
VDS networking with Foundation Load Balancer: Layer 4 only, VLAN-backed topologies, bundled with vCenter; chosen for simple or lab Supervisors. Avi Load Balancer is the fuller VDS option (L4/L7, GSLB).
NSX Tier-0/Tier-1 segments: the pre-VPC NSX model, still supported for existing designs.
Operational checks after activation
Supervisor status Running in Workload Management; control plane VMs on separate hosts/Zones; Kubernetes API reachable on the Supervisor virtual IP.
Content library synced (VKr images visible as kubectl get kubernetesreleases / VCF CLI vcf kubernetes-release get in a namespace context).
Namespace created with at least one storage class and VM class before the first VKS cluster request.
Lab note (Holodeck): the nested site's Supervisor can be activated with VPC networking on the workload domain cluster; use the Holodeck documented default sizes and expect single-Zone, one control plane VM in the nested footprint.
Key Takeaways
VCF 9.0 Supervisor minimums: 1 host without vSAN (3 recommended) or 3 with vSAN (4 recommended), 8 CPU / 64 GB per host, DRS Fully Automated + HA, vCenter 9.0 Small, NSX Manager Medium, two Large Edge nodes, TEP MTU > 1600, no IPv6 clusters.
Activation from VCF Operations at workload-domain creation uses VCF Networking with VPC by default; from the vSphere Client you choose the stack (NSX VPC, NSX segments, VDS + Foundation LB / Avi) and single vs three Management Zones.
Validate before the first cluster: Supervisor Running, control plane VMs spread, content library synced with VKr images, namespace with storage class and VM class.
VKS clusters are Cluster API clusters provisioned from a vSphere Namespace using the built-in ClusterClass. The legacy TanzuKubernetesCluster (TKC) API is deprecated in favour of the v1beta1 Cluster API.
Cluster manifest (VCF 9.0.1 — VKS cluster v1beta1 example, trimmed)
class is the built-in ClusterClass shipped with the Supervisor release (for example builtin-generic-v3.3.0); 'tanzukubernetescluster' is not a ClusterClass.
version is the VKr string from the content library; variables carry the vmClass and storageClass (and optional extras such as node labels, volumes, proxy, trust bundles).
Control plane replicas 1 or 3; MachineDeployments are generated from the topology — scale or edit the Cluster object, not the MachineDeployment.
Lifecycle operations
Operation
How
Create
kubectl apply -f cluster.yaml in the namespace context (kubectl with the vSphere plug-in, or VCF CLI vcf context + vcf cluster create), or through VCF Automation (CCI.Supervisor.Resource) / Terraform
Scale
Change replicas in the worker pool (or let the Cluster Autoscaler do it)
Autoscale
Install the Cluster Autoscaler standard package on the workload cluster, then set the min-size / max-size annotations on the worker pool; from VKr 1.31.4 scaling from and to zero is supported
Upgrade
Change spec.topology.version to a newer VKr (one minor at a time); control plane nodes roll first, then worker pools; respect PodDisruptionBudgets
Packages
Standard packages (Cluster Autoscaler, Velero, Harbor, external-dns, Contour, cert-manager, Fluent Bit, Prometheus/Grafana and others) from the package repository, installed with the VCF CLI package plug-in on the workload cluster
Backup
Velero standard package on the workload cluster (installing Velero through the Velero operator is deprecated); Kopia replaces Restic for file-system backups from Velero 1.15 (Restic restores end with 1.19)
Snapshots
Cluster-level snapshots of VKS clusters as documented for the release; volume snapshots via the vSphere CSI driver
Velero example (Schedule, not Backup, carries the cron expression)
Velero backs up Kubernetes API objects and volume data through the Kubernetes API and CSI snapshots; it is not an etcd snapshot. The Supervisor's own control plane is protected by vSphere HA and the Velero Supervisor Service.
Design guidance
One namespace per team or tenant with quota, storage classes and VM classes sized to the workload; several small clusters are easier to upgrade than one large one.
Pin VKr versions deliberately and plan the upgrade cadence against the VKS compatibility window (1.28–1.32 on VCF 9.0 with VKS 3.3.1).
Document autoscaler bounds, PDBs and the backup target per cluster class (dev/prod).
Key Takeaways
VKS clusters are Cluster API v1beta1 objects with the built-in ClusterClass (builtin-generic-v3.3.0), a VKr version string and vmClass/storageClass variables; TKC is deprecated; scale and upgrade by editing the Cluster, not the MachineDeployment.
Autoscaling = Cluster Autoscaler standard package + min/max-size annotations on the worker pool (scale to/from zero from VKr 1.31.4); packages are installed with the VCF CLI package plug-in.
Backup with the Velero standard package (operator install deprecated; Kopia replaces Restic): a Schedule carries the cron expression and a template, Backup objects do not.
Supervisor internals for the exam and the design defence (VCF 9.0.1 — Supervisor concepts; vSphere Pods)
Control plane availability
A three-VM Supervisor control plane is a stacked Kubernetes control plane: each VM runs kube-apiserver, etcd, controller-manager and scheduler. All three API servers serve requests behind the Supervisor virtual IP; etcd elects one leader and keeps quorum while two of three members are up, so one VM failure is tolerated; the scheduler and controller-manager use leader election among the three. The VCF docs describe three VMs running two instances of most controllers.
A one-VM Supervisor (single Management Zone default, or 'single host' Supervisor with vSphere HA deactivated) has no quorum protection; recovery is a vSphere HA restart or a manual rebuild. Scaling from one to three control plane VMs is a supported day-2 change; sizes only scale up.
Control plane VMs are system-managed VMs (not pods) placed on separate hosts (anti-affinity) or separate Zones.
vSphere Pods
A vSphere Pod is a VM with a small footprint that runs one or more Linux containers, managed by the Spherelet on the ESX host and run by the CRX runtime with its own Photon-based Linux kernel. Each pod is sized precisely for its workload with explicit reservations; DRS places it; it gets VM-level isolation while keeping container-like start-up time and overhead; OCI images run unchanged.
vSphere Pods are only supported when the Supervisor uses NSX networking. They are an alternative to VKS cluster nodes for small, isolated services, not the default location of Supervisor workloads.
The Kata containers comparison is not the VCF mechanism; do not cite it.
Networking inside the platform
Supervisor with NSX: per-namespace Tier-1 or VPC, segments/subnets, SNAT and load-balancer VIPs created by the Supervisor's NSX integration (the NCP-based integration in the Supervisor).
VKS clusters: Antrea (default) or Calico is the CNI (Table 1598), and the CNI enforces Kubernetes NetworkPolicy inside the cluster. Antrea–NSX integration applies to Antrea clusters: the Antrea NSX Adapter synchronises the cluster's Kubernetes network policies into the NSX inventory, where they cannot be edited (a one-way import through the NSX API converts them to vDefend DFW policies); DFW policies that NSX applies to an Antrea cluster are enforced by that cluster's Antrea Controller; and Antrea Traceflow can be started from NSX Manager.
Ingress and services: NSX load balancer, Avi, or Foundation Load Balancer depending on the stack; Contour as an in-cluster ingress package.
Identity and access
Supervisor access through vCenter SSO (and VCF SSO) with kubectl vsphere login, or through external OIDC identity providers configured on the Supervisor (Pinniped) so VKS clusters accept enterprise identities; VCF CLI contexts wrap the same login.
Namespace permissions (view/edit/owner) are granted to users or groups per namespace; in All Apps organizations VCF Automation project roles map onto them.
Multi-tenancy design checklist
Layer
Control
Compute/storage
vSphere Namespace quotas, VM classes, storage classes; Zones for failure domains
Network
NSX VPC per namespace; Antrea/NSX policies in clusters; Avi or NSX LB per tenant VIP range
Platform
Pod Security Admission levels per namespace; RBAC; separate Supervisors or Zones for hard isolation
Lifecycle
VKr version policy, upgrade windows per cluster class, Velero backup per tenant
Troubleshooting pointers
Supervisor activation stalls: check the Workload Management configuration status messages, DNS and NTP for the control plane VMs, content library sync, Edge cluster and Tier-0 health, TEP MTU (> 1600), and that host names are lower case.
VKS cluster stuck Provisioning:kubectl get cluster,machines -n <ns> and kubectl describe the Machine; usual causes are an exhausted IP pool, a VM class or storage class not assigned to the namespace, a content library without the requested VKr, or quota exhaustion.
Pods pending: node resources vs requests, storage class availability, Antrea agent health; for vSphere Pods confirm the Supervisor runs NSX networking.
Key Takeaways
HA control plane = three stacked control plane VMs; all three API servers serve behind the VIP, etcd quorum tolerates one failure, scheduler/controller-manager use leader election; one VM means vSphere HA restart is the recovery.
vSphere Pods are small-footprint VMs run by Spherelet/CRX with their own kernel, DRS-placed, NSX networking only; VKS cluster nodes are separate VMs with Antrea (default) or Calico as CNI (Antrea–NSX integration shows the cluster's Kubernetes policies in NSX read-only, and DFW policies that NSX applies to the cluster are enforced by its Antrea Controller).
Troubleshoot from the object chain: Workload Management status → Cluster/Machine objects → namespace VM class, storage class, content library and IP pool; verify TEP MTU > 1600 and lower-case host names at activation.
Supervisor architecture, networking stacks (NSX VPC, NSX segments, VDS, Avi, Foundation Load Balancer), identity providers, content libraries including air-gapped
VKS cluster lifecycle: Cluster API/ClusterClass, VKr versions, scaling and autoscalers, standard packages and package repositories, snapshots, Supervisor Service upgrades, kubectl and VCF CLI
Multi-tenancy and security: namespaces, quotas, NSX VPC isolation, Antrea/NSX policies, Pod Security Admission, RBAC, service mesh
Troubleshooting Supervisor activation, cluster provisioning, networking and storage
Note: VCDX Academy study groupings; the official 3V0-24.25 exam guide (docs.broadcom.com, 'VMware VCAP VKS exam guide') is the authority for objectives and must be cross-checked
Spherelet is a Kubernetes controller running on ESXi hosts that integrates Pod lifecycle with the hypervisor, enabling vSphere Pods. It's not a CNI plugin, monitoring agent, or NSX Edge service.
Production Supervisors deploy three Control Plane VMs in an HA set for etcd quorum. One provides no redundancy. Five is over-provisioned. Two with witness doesn't match Kubernetes HA patterns.
NSX-backed Supervisor provides NSX segments with a dedicated Tier-1 gateway per namespace, enabling overlay networking with full NSX security. VDS-backed uses distributed port groups. Antrea-only and host-only are not Supervisor backing options.
CAPV (Cluster API Provider vSphere) manages VKS cluster lifecycle via Cluster API CRDs, handling VM provisioning, scaling, and upgrades on vSphere. It doesn't scan images, run Harbor, or handle DNS resolution.
Supervisor control plane sizes are Tiny (2 CPUs, 8 GB), Small (4 CPUs, 16 GB), Medium (8 CPUs, 16 GB) and Large (16 CPUs, 32 GB), each with 32 GB storage. Tiny is the smallest; once a size is selected you can only scale up, never down (VCF 9.0.1 docs pp.5585, 5687).
In a VCF 9.0 Supervisor, the Supervisor Control Plane VMs are deployed in an HA triplet. What happens if two of the three Control Plane VMs fail simultaneously?
The Kubernetes API becomes unavailable because etcd loses quorum; Namespace operations and pod scheduling are interrupted until a CP VM is recovered
vCenter becomes the Kubernetes control plane until recovery
The Supervisor continues fully operational because Kubernetes uses leader election
Spherelet takes over the control plane role on ESXi
If two of three CP VMs fail, etcd loses quorum (needs 2 of 3), making the Kubernetes API unavailable. Namespace operations and pod scheduling are interrupted. Spherelet doesn't take over CP. vCenter doesn't become the K8s control plane. Leader election needs quorum to function.
A VKS cluster uses a managed topology: worker count is set on the Cluster object under spec.topology.workers.machineDeployments[].replicas, and Cluster API regenerates the MachineDeployment from it (edits made directly on the MachineDeployment are reverted). StorageClass, ClusterIssuer and HelmRelease are unrelated to node scaling.
cluster.x-k8s.io/cluster-api-autoscaler-node-group-min-size and -max-size annotations on MachineDeployments enable the Kubernetes Cluster Autoscaler. Other annotation patterns like kubernetes.io/role or metadata.autoscale are not valid.
MachineHealthCheck remediates unhealthy nodes by deleting and replacing the Machine object, triggering CAPI/CAPV to provision a new node. It doesn't just block scheduling, upgrade kernels, or cordon indefinitely.
VKr distributions are published as OVA packages in a content library (VCF 9.0.1 docs p.7132), so in an air-gapped environment you download the OVAs and upload them to a local content library (or an internally published library) associated with the namespace. Public access isn't available, air-gapped use is supported, and building from source isn't required.
VM Service classes define compute specifications (CPU/memory) for VKS worker VMs, providing T-shirt sizing. Pod network policy, image credentials, and StorageClass provisioners serve different purposes.
An operator needs to perform a minor Kubernetes version upgrade on a VKS workload cluster (e.g., 1.29 -> 1.30). What is the correct upgrade sequencing?
Re-deploy the cluster from scratch; in-place upgrades are not supported
Directly edit the ClusterClass to bypass the Supervisor
Upgrade the Supervisor to a version supporting the target TKR, subscribe the content library to the new TKR, then patch the Cluster/VKS cluster manifest
Upgrade the Supervisor first to a release that supports the target VKr, make the new VKr available through the namespace's content library, then update the Kubernetes version in the Cluster topology; the nodes are replaced by rolling update (VCF 9.0.1 docs p.5743). Worker-first ordering, editing the ClusterClass to bypass the Supervisor, and redeploying from scratch are all wrong: in-place rolling upgrades are supported.
A MachineDeployment is annotated with cluster.x-k8s.io/cluster-api-autoscaler-node-group-min-size=3 and max-size=10. After a burst of pending pods, no new nodes are provisioned. Which is the most likely cause?
TKRs must be re-imported
Cluster Autoscaler add-on is not installed on the workload cluster, so the annotations are ignored
If the Cluster Autoscaler add-on isn't installed on the workload cluster, the annotations are simply metadata with no effect — no component reads them. Anti-affinity, Supervisor locks, and TKR re-imports don't explain missing autoscaling when annotations are present but unused.
After the Ready=False condition persists past the 10m timeout, MHC deletes the Machine object, triggering CAPV to create a replacement node. It doesn't SSH to restart kubelet, just raise alerts, or drain-and-leave the node.
A VM class defines CPU and memory (with optional reservations and limits). VM classes are visible to all namespaces in vCenter, but DevOps users can only use the classes associated with their namespace (VCF 9.0.1 docs p.6910) — so 'always available to every Namespace' is only half true. VM classes are used by VKS nodes and VMs, not only vSphere Pods, and they don't override storage policies.
Air-gapped VKr ingestion: create a local content library (or subscribe to an internally published library), download the VKr OVA files and upload them, then associate the library with the namespace. Local and subscribed libraries are different library types. Internet access isn't required; SMB mounts and DHCP option 66 are not valid methods.
Increase spec.topology.workers.machineDeployments[].replicas on the Cluster resource; in a managed topology the MachineDeployment is generated from the Cluster and direct edits are reverted. Kubernetes Deployment replicas scale pods, not nodes. Adding ESXi hosts or resizing control plane VMs does not scale worker pools.
Per KB 390634 the VCF component order is SDDC Manager > NSX > vCenter > Supervisor > ESXi, with TKRs and workload clusters last. NSX precedes vCenter — this is true in VCF 5.2 as well. In VCF 9.x the fleet/management layer (VCF Operations and related appliances) upgrades before SDDC Manager.
AntreaNetworkPolicy is namespaced (VCF 9.0.1 docs p.2269: scope limited to a namespace); ClusterNetworkPolicy is cluster-scoped. Both add Tiers, explicit priorities and Allow/Drop/Reject/Pass actions that K8s NetworkPolicy lacks. They support ingress and egress, aren't limited to L2 filtering, and use label selectors.
Service type LoadBalancer on NSX-backed Supervisor is backed by Avi (NSX ALB) or native NSX LB for external IP allocation. HAProxy is for older TKG deployments. kube-proxy handles ClusterIP only. MetalLB is for bare-metal K8s.
Contour/Envoy provides Ingress controller functionality with path/host-based routing, TLS termination, and HTTP routing rules. It's not a CSI driver, Antrea replacement, or Cluster API provider.
Antrea Traceflow captures the packet walk between pods for troubleshooting, similar to NSX Traceflow but within the K8s overlay. It doesn't rotate certificates, replace kube-proxy, or upgrade Supervisor.
Each vSphere Namespace with NSX-backed networking gets a dedicated Tier-1 gateway and segments, providing network isolation per namespace. Shared segments, no isolation, and VLAN-only don't provide the NSX-backed isolation model.
Centralized Transit Gateway (CTGW) connects multiple VPCs through a common gateway for shared services and transit connectivity. It doesn't replace Antrea, isn't a StorageClass, and doesn't scan container images.
Creating a LoadBalancer Service dynamically provisions a virtual server on Avi or NSX native LB with the external IP allocated from the Ingress CIDR pool. It doesn't create DHCP segments, VRF gateways, or redeploy Edge clusters.
Two pods in different Namespaces of the same workload cluster cannot communicate. An AntreaClusterNetworkPolicy in the Baseline tier allows the traffic. What is the next check?
Restart kube-proxy
Change the CNI to Calico
Look for a Kubernetes NetworkPolicy that selects the destination pod: it isolates the pod, K8s NetworkPolicies are enforced before Baseline-tier Antrea policies, and traffic they do not allow is dropped
Antrea enforces Antrea-native policies by tier: every tier except Baseline is evaluated before Kubernetes NetworkPolicies, then the K8s NetworkPolicies, then the Baseline tier. An ACNP Allow in a normal tier would therefore win, but a Baseline-tier Allow is overridden by a K8s NetworkPolicy that selects the pod — such a policy isolates the pod and anything it does not allow is dropped (K8s NetworkPolicy has no explicit deny rules). Restarting kube-proxy, rotating tokens or changing the CNI do not resolve policy precedence.
CTGW aggregates routing and north-south connectivity for multiple VPCs in a Project and connects upstream to the Tier-0 gateway. Each VPC doesn't have its own CTGW. CTGW doesn't replace NSX Manager or perform L2 bridging.
Envoy proxy managed by Contour terminates TLS using the TLS secret referenced in the Ingress/HTTPProxy resource. Application pods don't need to handle TLS when using Ingress. kube-proxy doesn't do TLS. NSX Edge TLS Passthrough is a different mechanism.
vSphere CSI driver references a StorageClass mapped to a vSAN storage policy for dynamic PV provisioning. NFS subdir provisioner is for external NFS. HostPath and local static PVs aren't dynamically provisioned by CSI.
RWX (ReadWriteMany) is supported by vSAN File Services-backed PVs. RWO is for block volumes. ROX is read-only many. vSAN File Services enables shared access via NFS v4.1.
Volume expansion requires allowVolumeExpansion: true on the StorageClass AND CSI driver support. reclaimPolicy controls what happens after PVC deletion. mountOptions define mount flags. Default settings don't enable expansion.
CNS (Cloud Native Storage) manages the PVC-to-VMDK lifecycle and provides visibility in vCenter for persistent volumes. It doesn't replace ESA, run Helm, or scan images.
A VolumeSnapshot requires a VolumeSnapshotClass referencing the CSI driver and snapshotter CRD. Just a PV, pod annotation, or StorageClass without provisioner is insufficient.
vSAN File Services-backed PVC with RWX supports shared access from multiple pods for stateful web uploads. Block RWO limits access to one pod. HostPath isn't shared across nodes. EmptyDir is ephemeral.
Online volume expansion requires allowVolumeExpansion=true, CSI driver support for online expansion, and vSAN policy allowing capacity growth. VMFS-6, PVC recreation, and vCenter upgrades are not the correct requirements.
Pod Security Admission 'restricted' enforces the strictest hardened baseline, prohibiting privileged containers, host namespaces, and dangerous capabilities. 'No policy' corresponds to the Privileged profile (unrestricted), the opposite of restricted; Baseline is the middle profile that blocks known privilege escalations. Network policies are separate.
Harbor provides a private container image registry with RBAC, vulnerability scanning (Trivy), image replication, and signing (Notary). It's not limited to replacing kube-proxy, providing CSI, or monitoring.
Velero backs up and restores cluster resources (manifests) and PV snapshots for disaster recovery. It doesn't handle autoscaling, ingress routing, or Antrea Traceflow.
Pending PVCs most often result from no matching StorageClass or unavailable storage policy/capacity. Incorrect pod security, missing ingress routes, and HPA misconfig don't affect PVC binding.
RoleBinding referencing a Role scoped to a namespace grants fine-grained access to that namespace only. ClusterRoleBinding to cluster-admin is overprivileged. No RBAC is insecure. Pinniped handles authentication, not authorization.
Velero backs up a namespace that contains PVCs. For vSAN-backed volumes using CSI snapshots, which requirement is needed for application-consistent backups of a MySQL StatefulSet?
Enable vSAN dedupe
Use Velero backup hooks (pre/post freeze commands) or CSI snapshots combined with an application-quiescing tool such as fsfreeze or DB flush/lock scripts
A cluster admin applies the Pod Security Admission label pod-security.kubernetes.io/enforce=restricted to a namespace. Which pod spec is MOST likely to be rejected?
A pod using readOnlyRootFilesystem=true
A pod with resource limits set
A pod with runAsNonRoot=true and no capabilities
A pod requesting hostNetwork=true and privileged=true
A pod with hostNetwork=true and privileged=true violates the 'restricted' PSA profile which prohibits host namespaces and privileged access. runAsNonRoot, readOnlyRootFilesystem, and resource limits are compliant with restricted.
Harbor's project role matrix grants Scan to Maintainer and Project Admin; a Developer can push and pull but cannot trigger a scan, which matches the symptom (push works, scan does not). A missing or unconfigured scanner would block scans for every user, not this one developer. Image tag and Notary signing are unrelated.
First check the Supervisor LoadBalancer IP pool for available addresses and Ingress/Egress CIDR exhaustion — IP exhaustion is the most common cause of pending LoadBalancer Services. Pod deletion, kubelet restart, and Edge reboot won't fix IP allocation issues.
RoleBinding referencing a Role with verbs [get, list, watch] on pods in a specific namespace provides read-only pod access. ClusterRoleBinding with cluster-admin is over-privileged. RoleBinding to 'edit' grants write access. ServiceAccount without RBAC has no permissions.
Authentication succeeded (OIDC tokens are valid) but no RBAC binding grants permissions — the user/group needs a RoleBinding or ClusterRoleBinding to access cluster resources. Pinniped doesn't need NFS. The kubeconfig is valid if auth succeeded.
Prometheus scrapes metrics from kube-state-metrics but not from cAdvisor. Which configuration is most likely missing?
Harbor TLS certificate
The ServiceMonitor (or scrape config) targeting the kubelet /metrics/cadvisor endpoint, and the correct RBAC permissions for the Prometheus service account to access nodes/metrics
The ServiceMonitor (or scrape config) targeting kubelet /metrics/cadvisor endpoint plus RBAC for the Prometheus service account to access nodes/metrics is missing. Grafana dashboards, Alertmanager webhooks, and Harbor certs don't affect metric scraping.
The vSphere cluster where VKS is enabled, with its Control Plane VMs running Kubernetes APIs and its ESXi hosts running Spherelet. It hosts vSphere Pods and manages downstream VKS guest clusters. It is the foundational layer of the three-layer VKS architecture.
Spherelet
A kubelet-equivalent process running on each ESXi host when the cluster is enabled as a Supervisor. It enables running pods natively on ESXi inside a CRX (Container Runtime Executive). Spherelet integrates Kubernetes scheduling with vSphere. Note: vSphere Pods are deprecated in VCF 9; VKS workloads primarily run in Tanzu Kubernetes guest clusters.
CRX (Container Runtime Executive)
A minimal, purpose-built VM that ESXi uses to isolate vSphere Pods at hardware-virtualization strength. CRX boots in under a second and carries only what a container needs. It provides VM-strong isolation for pods without a conventional guest OS.
Supervisor Service
A management-plane extension running on the Supervisor that provides platform capabilities (VKS, Contour, Harbor, External-DNS, LCI). Services are installed via the Supervisor Services catalog in vCenter. They are the pluggable ecosystem of VKS.
Cluster API Provider vSphere (CAPV)
The Kubernetes Cluster API implementation that provisions and lifecycles VKS guest clusters declaratively from the Supervisor. CAPV translates ClusterClass specs into VMs and kubeadm configuration. It is the engine behind 'create cluster' operations.
VDS-Backed Supervisor
A Supervisor networking mode that uses plain VDS port groups plus an external load balancer (Avi/HAProxy) instead of NSX. It is lighter-weight but lacks NSX-native isolation and service chaining. It is suitable for VVF-adjacent VKS-only scenarios.
Supervisor Control Plane VMs
Three control-plane VMs deployed by vCenter on the Supervisor cluster, running kube-apiserver, etcd, scheduler, controller-manager, plus VMware-specific controllers (VM-operator, CAPV, NCP/AKO).
vSphere Pod (vSphere Native Pod)
A legacy NSX-only Supervisor construct running pods directly on ESXi via CRX. Deprecated in favor of TKG clusters running on VM-operator VMs; still appears on exam objectives for older paths.
Namespace (Supervisor)
The primary multi-tenancy object in the Supervisor, binding user permissions, storage policies, VM classes, content libraries, and resource limits. Each namespace maps to a Kubernetes namespace on the Supervisor.
VM Class
A template describing the CPU/memory/GPU reservation of a VM provisioned by VM-operator or used as TKG node. Bound to namespaces; users pick a class when creating clusters. Custom classes allow right-sizing of TKG worker pools.
ClusterClass
A reusable Kubernetes Cluster API template defining worker/control-plane topology, machine specs, and add-ons, instantiated by Cluster objects. VKS ships curated ClusterClasses but customers can author their own. It is the blueprint of a VKS guest cluster.
MachineDeployment
A Cluster API resource that manages a set of worker-node VMs with desired replica count, similar to a Kubernetes Deployment but for VMs. Changing replicas triggers Spherelet to provision or drain nodes. It is the scaling primitive for VKS guest workers.
Tanzu Kubernetes Release (TKR)
A versioned bundle of Kubernetes, OS, and vSphere-supplied components used as the base for VKS guest cluster nodes. New TKRs bring upstream K8s versions and security fixes. Cluster upgrades consume newer TKRs via CAPV.
MachineHealthCheck
A Cluster API resource that monitors node conditions and automatically remediates unhealthy machines by replacement. It is the self-healing mechanism for VKS. It is configured with thresholds so transient issues do not trigger needless churn.
VM Operator
A Supervisor component that translates Kubernetes VM custom resources into vSphere VMs with full lifecycle management. It lets teams request VMs via kubectl, bridging VM and container workflows. It is closely related to VM Service classes.
Cluster Autoscaler (VKS)
An add-on that watches pending pods in guest clusters and scales MachineDeployment replicas up or down within configured min/max annotations. It translates pod demand into node capacity automatically. It is the standard mechanism for elastic worker pools.
TKG Control Plane Upgrade
A ClusterClass-driven rolling update that replaces control-plane VMs one at a time using a new TKR. etcd quorum is preserved as each node is cordoned, drained, and replaced.
Worker Rolling Update Strategy
MachineDeployments default to rolling update with configurable maxSurge and maxUnavailable; MachineHealthCheck can auto-remediate unhealthy nodes during the update.
MachineSet
The CAPI object that maintains a set of identical Machines (VMs); owned by a MachineDeployment. Scaling the MD creates/removes MachineSets during rolling updates.
VM Service (VM Operator)
Supervisor service that lets namespace users declaratively request standalone VMs via 'VirtualMachine' and 'VirtualMachineService' CRDs; VMs consume the same VM classes and images as TKG nodes.
Antrea CNI
The default container-network interface in VKS, providing pod networking, NetworkPolicies, and cluster-scoped policies using Open vSwitch. It is chosen for its NSX integration and visibility features. It powers both cluster and namespace-scoped network controls.
AntreaNetworkPolicy (ANP)
A namespace-scoped Kubernetes CRD that extends the standard NetworkPolicy with tiered rules, drop/reject actions, and richer selectors. It provides the expressiveness of enterprise firewalls inside Kubernetes. It is the recommended policy type for Antrea users.
ClusterNetworkPolicy (CNP)
A cluster-scoped Antrea CRD that enforces network rules across all namespaces, typically for platform-level security baselines. It is evaluated before namespace-scoped policies. It is administered by platform teams, not tenants.
LoadBalancer Service (VKS)
A Kubernetes Service type that VKS fulfills by requesting a VIP on the integrated load balancer (Avi or NSX LB). Each LB service consumes a VIP and backend pool. It is the typical ingress for non-HTTP workloads.
Contour Ingress
The default VKS Ingress controller (installed as a Supervisor Service) that translates Kubernetes Ingress and HTTPProxy resources into Envoy proxy configuration. It provides L7 HTTP/HTTPS routing at the cluster edge. It integrates with Harbor and External-DNS.
Antrea Traceflow
An Antrea-specific live packet-trace capability that shows each hop a packet takes through the CNI, including policy matches. It is invaluable when a pod can't reach another pod and NetworkPolicy may be involved. Its output is rendered both in YAML and in the Antrea UI.
NCP (NSX Container Plugin)
Controller that integrates Kubernetes with NSX, creating Tier-1 routers, segments, LBs, and DFW rules for namespaces, pods, and services. Required for NSX-backed Supervisors.
Egress IP Pool
Pool of NSX IPs from which namespace workloads SNAT when leaving the cluster. Allows firewall rules upstream to identify traffic by namespace.
Antrea Proxy Mode
Antrea can implement kube-proxy replacement in-kernel using OVS, improving Service throughput vs iptables. Proxy-all mode extends this to all Service types.
NetworkPolicy Object Ordering
Kubernetes NetworkPolicy is additive (union of allow rules). AntreaClusterNetworkPolicy adds tiers and priorities, enabling deny/allow ordering similar to NSX DFW categories.
vSphere CSI Driver
The Container Storage Interface implementation that provisions Kubernetes PersistentVolumes as vSAN or VMFS VMDKs on vSphere. It is installed automatically in VKS. It supports dynamic provisioning, snapshots, and expansion.
StorageClass (VKS)
A Kubernetes resource mapping a friendly name (for example, 'gold-ssd') to a vSAN storage policy plus access-mode defaults. StorageClasses decouple application manifests from storage-backend specifics. They are the tenant-visible storage catalog.
ReadWriteMany (RWX) Volume
A Kubernetes access mode that allows multiple pods on multiple nodes to mount the same volume concurrently, implemented in VKS via vSAN File Services-backed NFS. It is used for shared-config workloads and legacy apps. Not all StorageClasses support RWX.
VolumeSnapshot
A Kubernetes CRD that captures a point-in-time copy of a PersistentVolume, implemented in vSphere CSI as an underlying vSAN snapshot. It enables database backup-and-restore workflows without leaving kubectl. It requires a VolumeSnapshotClass bound to the right CSI driver.
Cloud Native Storage (CNS)
The vSphere subsystem that tracks Kubernetes PVCs as first-class vCenter objects, exposing relationship and metric data to Ops teams. It is what enables VCF Operations to show per-PVC capacity and performance. It is the backplane behind every VKS PVC.
PVC Binding Mode
A StorageClass attribute controlling when a PVC is bound to a PV: Immediate provisions at PVC creation, WaitForFirstConsumer delays until a pod is scheduled. WaitForFirstConsumer is recommended for topology-aware placement. It is a common VKS exam topic.
Storage Policy Mapping to StorageClass
vSphere storage policies exposed to a namespace appear as Kubernetes StorageClasses; PVCs reference them by name. Policy compliance is visible in vCenter and reported back to CNS.
CNS Volume Types
CNS backs PVCs with First-Class Disks (FCDs) on vSAN/VMFS/NFS and RWX via vSAN File Services. Type is chosen by StorageClass parameters (datastoreURL, fsType, CSI topology).
Volume Expansion
Online expansion of PVCs supported when StorageClass 'allowVolumeExpansion: true' and underlying datastore supports it. CSI driver orchestrates filesystem resize inside the pod.
VolumeSnapshotClass
CRD defining snapshot parameters (snapshotter, deletionPolicy). Binds CSI snapshotter to underlying FCD snapshots; used by VolumeSnapshot objects for per-PVC backups.
vSphere SSO Integration (VKS)
The mechanism that lets vCenter SSO users authenticate to VKS clusters via Kubernetes RBAC with Viewer/Editor/Owner role mapping. It avoids separate Kubernetes user stores for platform users. It is the default auth path for VKS in VCF.
Pinniped
An open-source authentication add-on that bridges external IdPs (OIDC, LDAP) into Kubernetes authentication for VKS. It issues short-lived credentials to kubectl. It is the recommended way to federate enterprise identities into tenant clusters.
Pod Security Admission (PSA)
The built-in Kubernetes admission controller replacing PodSecurityPolicy, evaluating pods against Privileged, Baseline, and Restricted profiles. Namespaces opt into a profile via labels. PSA is the default pod-security control in modern Kubernetes and VKS.
Harbor Registry (VKS)
The VKS-integrated private container registry Supervisor Service that stores and scans images for vulnerabilities with Trivy. It supports replication, signing, and RBAC. It is the preferred image source for VKS workloads.
Velero Backup
A Kubernetes-native backup tool that snapshots resources and PVs, commonly deployed for VKS with vSphere CSI snapshot support. It supports scheduled backups and cross-cluster restores. It is the standard Kubernetes BCDR utility on VKS.
ClusterRoleBinding
A Kubernetes RBAC resource that grants a ClusterRole (a cluster-wide permission set) to users, groups, or service accounts. It contrasts with RoleBinding, which is namespace-scoped. Correct use is essential for least-privilege VKS administration.
Workload Management Roles
vSphere SSO roles that expose VKS: 'Can Edit' (namespace owner), 'Can View' (read-only), plus custom roles built from Namespace-level privileges. Assigned via Namespace → Permissions.
Image Signing / Registry Scan
Harbor (Supervisor Service) supports Notary/Cosign signature validation and Trivy image scanning; pull policies can require signed images for a project.
Cluster Audit Logging
API-server audit log levels configured on TKG control planes via ClusterClass patches; shipped via a sidecar or Fluent Bit to external syslog/SIEM for compliance.
TKG Backup with Velero Plugin for vSphere
Plugin enables snapshot-based PV backup using CNS snapshots in parallel with Velero object backup. Required for application-consistent backups of stateful workloads.
Was this page useful?Thanks — noted.
Type to search. ↑↓ to move,
Enter to open, Esc to close.