Google PCA Manage and provision cloud infrastructure Practice Question
A company runs a microservices application on Google Kubernetes Engine (GKE). Each service is deployed as a Deployment with resource requests and limits. After deploying a new version of a service, the pods start crashing with OOMKilled. The team increased the memory limits in the Deployment manifest, but the pods still crash after a few minutes. The cluster has cluster autoscaling enabled. The node pool has sufficient capacity. What is the most likely cause of the issue?
⚠ Common exam trap
A common mix-up: candidates confuse resource limits with scaling mechanisms, assuming that increasing limits or enabling autoscaling fixes memory exhaustion, rather than recognizing the application-level memory leak as the root cause.
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
✓
The application has a memory leak
The pods are crashing with OOMKilled even after increasing memory limits, and the node pool has sufficient capacity. This indicates the application itself has a memory leak, where memory usage grows unbounded over time until it exceeds the new limit, causing the OOMKiller to terminate the pod. Increasing limits only delays the crash if the leak persists.
Answer analysis
Option-by-option breakdown
For each option: why learners choose it and why it is or isn't the right answer here.
- ✗
The Horizontal Pod Autoscaler is configured with a wrong target metric
Why it's wrong here
HPA adjusts replica counts based on a target metric; it never changes a container's memory limit, so a misconfigured target cannot cause OOMKilled. HPA is the right tool when traffic-driven scaling of replica counts is needed, not when a container exceeds its own memory limit.
- ✗
The cluster autoscaler is not scaling up quickly enough
Why it's wrong here
Cluster autoscaler adds nodes when pods are Pending due to insufficient node capacity; the stem states the node pool has sufficient capacity, and OOMKilled is a container-level event. Autoscaling is correct when unschedulable pods need extra nodes.
- ✓
The application has a memory leak
Why this is correct
Raising memory limits only delays OOMKilled termination; pods still crash once consumption exceeds the new ceiling. Steadily growing memory that eventually exhausts any limit indicates a leak in the application code, not insufficient node capacity or autoscaling.
- ✗
The pods are hitting the node's ephemeral storage limit
Why it's wrong here
Exceeding ephemeral storage evicts pods with an Evicted status, not OOMKilled, which the kernel reports when a container exceeds its memory cgroup limit. Ephemeral storage limits matter when pods write large temporary files to the node's local disk.
Go deeper
Related to this question
Learn chapter
Google Cloud Resource Hierarchy and Organization
Key term
Anthos
Anthos is a Google Cloud platform that lets you run applications consistently across different computing environments, like on-premises data centers and multiple public clouds.
Key term
Microservices
Microservices is an architectural style where a software application is built as a collection of small, independent services, each handling a specific business function and communicating over a network.
About these practice questions
This PCA question is part of Courseiva's 807-question bank — original exam-style content with full explanations and wrong-answer analysis, never real exam questions or exam dumps. Learn why practice questions differ from exam dumps →
JA
Written by Johnson Ajibi, MSc IT Security
Senior Network & Security Engineer · founder of Courseiva
This PCA 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 PCA exam.