Cloud Digital Leader Google Cloud Products and Services Practice Question
A company runs a microservices application on Google Kubernetes Engine (GKE) and wants to reduce costs by using preemptible nodes for stateless workloads. However, they need to ensure that critical stateful workloads are not disrupted. Which two actions should they take?
Answer choices
Why each option matters
Answer the question above first, then reveal the full breakdown to understand why each option is right or wrong.
Correct answer & explanation
✓
Taint the regular node pool and use tolerations for stateful pods
To protect stateful workloads, use node pools with regular VMs and taint them to prevent preemptible pods from scheduling. For stateless workloads, use a separate node pool with preemptible VMs and add tolerations to the pods. Affinity rules or priority classes can also help but are not the primary method.
Answer analysis
Option-by-option breakdown
For each option: why learners choose it and why it is or isn't the right answer here.
- ✓
Taint the regular node pool and use tolerations for stateful pods
Why this is correct
Taints on regular nodes with tolerations for stateful pods create an explicit scheduling contract: any pod without the matching toleration is blocked from the regular node pool, while stateful pods that declare the toleration are placed there exclusively. This ensures preemptible or stateless workloads cannot consume resources on those nodes, giving stateful services stable, non-preemptible infrastructure and predictable lifecycles.
- ✗
Use a single node pool with a mix of regular and preemptible VMs
Why it's wrong here
A GKE node pool is uniform by design: you cannot mix preemptible and regular VM types in the same pool because they must share the same machine configuration, billing model, and node management settings. Even if the mix were possible, stateful pods would be scheduled on whichever node has capacity, so a preemptible node could host them and be terminated without notice, jeopardizing data durability and application availability.
- ✗
Set pod priority class to 'high' for stateful workloads
Why it's wrong here
Pod priority classes influence the order of eviction during resource contention and allow higher-priority pods to preempt lower-priority ones, but they have no bearing on where a pod is initially scheduled. A stateful pod with a high priority can still be placed on a preemptible node because no node-level constraint is applied, and when GKE reclaims that preemptible instance, the pod is terminated despite its priority.
- ✓
Create a separate node pool for preemptible VMs and use tolerations for stateless pods
Why this is correct
If the preemptible node pool is tainted (as GKE does automatically with preemptible=true), attaching the matching toleration to only stateless pods lets them take advantage of the cheaper preemptible nodes while stateful pods, lacking that toleration, are forced onto the regular, untainted node pool. This cleanly separates the two workload classes and prevents stateful services from ever being scheduled on a preemptible VM.
- ✗
Use node affinity rules to schedule stateful pods on regular nodes
Why it's wrong here
Node affinity lets you specify requirements or preferences for the node labels that stateful pods run on, but it does not restrict other pods from also scheduling onto those same regular nodes. Regular nodes can become overcommitted by stateless pods, and the stateful pods may still face resource contention; taints, by contrast, repel any pod that lacks the corresponding toleration, providing an absolute guarantee of node-pool exclusivity.
Go deeper
Related to this question
Learn chapter
Benefits of Google Cloud
Key term
Google Kubernetes Engine
Google Kubernetes Engine (GKE) is a managed Kubernetes service on Google Cloud that lets you deploy, scale, and manage containerized applications without having to operate the underlying cluster control plane.
Key term
Node pool
A node pool is a group of virtual machines (nodes) within a container orchestration cluster that share the same configuration, such as machine size, operating system, and scaling settings, allowing you to manage them as a single unit.
About these practice questions
One of 829 original GCDL practice questions on Courseiva, each with a full explanation and wrong-answer analysis — not exam dumps or protected exam content. Learn why practice questions differ from exam dumps →
JA
Written by Johnson Ajibi, MSc IT Security
Senior Network & Security Engineer · founder of Courseiva
This GCDL practice question is part of Courseiva's free Google Cloud certification practice question bank. Courseiva provides original exam-style practice questions with explanations, topic-based practice, mock exams, readiness tracking, and study analytics to help learners prepare for the GCDL exam.