Node pools and auto scaling in GCP - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Architecture

intermediate

How does a node pool affect cluster scaling in GKE?

You have a Google Kubernetes Engine (GKE) cluster with two node pools: one for general workloads and one for high-memory workloads. You want to enable auto scaling to adjust the number of nodes based on demand.

Which statement best describes how node pools influence auto scaling behavior?

A Each node pool scales independently based on the resource requests of pods scheduled to it.

B Auto scaling adjusts the total number of nodes in the cluster without considering node pools.

C Only the default node pool can be auto scaled; additional node pools remain fixed size.

D Node pools must have the same machine type to enable auto scaling across the cluster.

💡 Hint

Think about how pods are assigned to node pools and how scaling reacts to workload demands.

In GKE, each node pool can be configured with its own auto scaling settings. The cluster autoscaler adjusts the size of each node pool independently based on the resource requests of pods scheduled to that pool.

❓ Configuration

intermediate

Identify the correct YAML snippet to enable auto scaling on a GKE node pool

You want to enable auto scaling on a GKE node pool named high-mem-pool with a minimum of 2 nodes and a maximum of 5 nodes.

Which YAML snippet correctly configures this?

A

nodePools:
- name: high-mem-pool
  autoscaling:
    enabled: true
    minCount: 2
    maxCount: 5

B

nodePools:
- name: high-mem-pool
  autoscaling:
    enabled: true
    minNodeCount: 2
    maxNodeCount: 5

C

nodePools:
- name: high-mem-pool
  autoscaling:
    enabled: false
    minNodeCount: 2
    maxNodeCount: 5

D

nodePools:
- name: high-mem-pool
  autoscaling:
    minNodeCount: 2
    maxNodeCount: 5

💡 Hint

Check the exact field names required to enable autoscaling in GKE node pool configuration.

The autoscaling block must include enabled: true along with minNodeCount and maxNodeCount to properly enable autoscaling on a node pool.

❓ service_behavior

advanced

What happens when a pod requests more resources than any node in the node pool can provide?

You have a GKE cluster with a node pool of machines each having 4 CPU cores and 16 GB RAM. A pod requests 8 CPU cores and 32 GB RAM.

What will be the behavior of the cluster autoscaler and scheduler?

A The pod will be split across multiple nodes to satisfy resource requests.

B Autoscaler will add more nodes until the pod fits; scheduler places the pod once enough nodes exist.

C The scheduler will not place the pod; autoscaler will not add nodes because no node can satisfy the request.

D The scheduler will place the pod on the node with the most free resources, ignoring resource limits.

💡 Hint

Consider how Kubernetes schedules pods and how autoscaler reacts to unschedulable pods.

Kubernetes scheduler cannot place a pod if no single node has enough resources. The autoscaler only adds nodes if a pod can fit on a new node type. Since the pod requests more than any node can provide, it remains unschedulable and autoscaler does not add nodes.

❓ security

advanced

Which node pool configuration improves security by isolating sensitive workloads?

You want to run sensitive workloads in a GKE cluster with enhanced security. Which node pool configuration best isolates these workloads?

A Create a dedicated node pool with nodes having Shielded VM enabled and use node taints to isolate pods.

B Use the default node pool and label sensitive pods with a security label only.

C Run all workloads on the same node pool but use network policies to isolate traffic.

D Create a node pool with larger machines and run sensitive and non-sensitive pods together.

💡 Hint

Think about physical and logical isolation methods in Kubernetes node pools.

Creating a dedicated node pool with Shielded VMs and using taints ensures sensitive workloads run on isolated, secure nodes. Labels alone or network policies do not isolate nodes physically.

🧠 Conceptual

expert

Why might enabling cluster autoscaler on multiple node pools cause unexpected scaling behavior?

You enabled autoscaling on three node pools in a GKE cluster. You notice that sometimes one node pool scales up aggressively while others remain at minimum size, even though workloads are balanced.

What is the most likely cause?

A The cluster autoscaler requires all node pools to have identical resource limits to scale evenly.

B The autoscaler prioritizes scaling node pools with cheaper machine types first, causing uneven scaling.

C Autoscaler cannot scale multiple node pools simultaneously and picks one at random to scale.

D Pods have node selectors or affinity rules that restrict them to specific node pools, causing autoscaler to scale only those pools.

💡 Hint

Consider how pod scheduling constraints affect node pool scaling.

If pods have node selectors or affinity rules, they can only be scheduled on certain node pools. The autoscaler scales only the node pools that can host the pods, leading to uneven scaling.