Courseiva

Google PCA Ensure solution and operations reliability Practice Question

A company deploys a microservices application on Google Kubernetes Engine (GKE). Pods in one deployment are frequently OOMKilled. The team sets memory requests and limits, but pods still crash. What is the most likely remaining cause?

⚠ Common exam trap

Many exam-takers confuse OOMKilled (per-container limit) with node-pressure eviction (node-level memory), or assume that setting requests/limits automatically fixes all memory issues, ignoring application-level bugs like memory leaks.

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 that eventually exceeds the limit.

OOMKilled errors occur when a container exceeds its memory limit. Setting memory requests and limits prevents unbounded usage, but if the application has a memory leak, it will continue to consume memory until it hits the configured limit, causing the kernel's Out-Of-Memory (OOM) killer to terminate the pod. The fact that pods still crash after setting limits indicates the application itself is the root cause, not resource configuration.

Answer analysis

Option-by-option breakdown

For each option: why learners choose it and why it is or isn't the right answer here.

  • ✗

    CPU requests are too low, causing throttling and eventual crash.

    Why it's wrong here

    Insufficient CPU requests cause throttling and latency, not OOMKills, which the kernel triggers on memory limit breach. It tempts because resource starvation looks similar, but low CPU requests would be the correct diagnosis for performance degradation rather than container termination.

  • ✗

    The node pool is too small, causing memory pressure on the node.

    Why it's wrong here

    Node memory pressure evicts pods by priority and QoS class, producing Evicted status, not OOMKilled, which the kernel raises when a container exceeds its own cgroup limit. It tempts because undersized nodes cause memory problems, and would be correct for diagnosing eviction or scheduling failures.

  • ✗

    Memory limits are set higher than the node's allocatable memory.

    Why it's wrong here

    A limit exceeding node allocatable memory prevents scheduling rather than causing OOMKills; the kubelet rejects pods whose limits exceed capacity. It tempts because oversized limits look dangerous, but it is correct reasoning only when diagnosing Pending pods, not runtime memory exhaustion.

  • ✓

    The application has a memory leak that eventually exceeds the limit.

    Why this is correct

    Requests and limits only cap consumption; they cannot prevent a leak from growing until the container exceeds its limit and is OOMKilled. Since configuration is already correct, the remaining cause is application-level: unbounded allocation that eventually surpasses the configured memory limit.

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 →

How Courseiva writes practice questions · Editorial policy

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.