Open book — kubernetes.io docs only, not general web search
0 / 22 completed
1 / 22
A candidate researching the CKA reads that it is a "100% performance-based, hands-on exam." What does this mean in practice, and how does it differ from most other IT certification exams?
The CKA is unusual among IT certifications precisely because it has zero multiple-choice questions — it is entirely command-line, task-based work inside remote terminal sessions connected to real clusters. This is a critical vocabulary distinction for non-native candidates researching "how to study for CKA": phrases like "PBQ" (used by CompTIA) don't apply here — the whole exam is effectively one long, graded PBQ.
CKA exam-format facts and their vocabulary:
2-hour time limit, roughly 15–20 tasks, weighted by difficulty rather than counted equally
Open-book — candidates may reference kubernetes.io official documentation in a browser tab during the exam, but no other sites
Killer.sh — the official practice-exam simulator included with registration, widely referenced in study materials as "harder than the real exam"
Renewal required every 3 years through CNCF (Cloud Native Computing Foundation), the certifying body
Because it is hands-on, CKA study vocabulary centres on commands and workflows, not definitions — "know how to do it," not just "know what it means."
2 / 22
A CKA task instructs: "Take a snapshot of the etcd cluster and save it to /opt/etcd-backup.db." What is being tested here, and why is this specifically an administrator-level task rather than a developer-level one?
etcd is Kubernetes' distributed key-value store holding the entire desired and current state of the cluster. Backup and restore is a signature CKA task because it is squarely a cluster administrator responsibility — application developers (tested on CKAD instead) never need to touch etcd directly.
Core CKA cluster-administration vocabulary, distinct from CKAD's developer focus:
kubeadm — the tool used to bootstrap and manage a cluster's control plane (init, join, upgrade)
cordon / drain / uncordon — mark a node unschedulable, safely evict its pods for maintenance, then return it to service
Static pod — a pod managed directly by the kubelet on a specific node (not the API server) — used for control-plane components themselves
Admission controller — a plugin that intercepts API requests before persistence, used to enforce cluster-wide policy
Node conditions — Ready, MemoryPressure, DiskPressure, PIDPressure — the vocabulary for diagnosing why a node is unschedulable
These terms rarely appear on CKAD, which instead centres on how applications are packaged and exposed — the vocabulary split mirrors the real-world split between platform/infra engineers and app developers.
3 / 22
A CKA task says: "Troubleshoot why Node worker-2 shows status NotReady, and restore it to Ready." Which combination of investigation steps reflects correct CKA troubleshooting vocabulary and workflow?
A NotReady node status almost always traces back to the kubelet — the node agent responsible for reporting node health and running pods — being stopped, crashed, or unable to reach the API server. Correct CKA troubleshooting vocabulary and sequence: check node conditions and Events via kubectl describe node, then drop to the node itself to inspect the kubelet service and its systemd logs.
Precise troubleshooting vocabulary tested on CKA (a full exam domain, "Troubleshooting"):
Control plane component failure — diagnosing kube-apiserver, kube-scheduler, kube-controller-manager, or etcd issues via static pod manifests and container logs
Application failure vs. infrastructure failure — distinguishing a misconfigured Deployment from a genuine node/network issue
Network troubleshooting — DNS resolution failures inside the cluster (CoreDNS), Service endpoint mismatches
Because the exam is graded on actually restoring the cluster to a working state, not just diagnosing it, CKA vocabulary always pairs a diagnosis term ("NotReady", "CrashLoopBackOff") with a corresponding fix action — reading comprehension alone is not enough to pass.
4 / 22
A CKA task requires creating a Role that only permits "get" and "list" on pods within the "dev" namespace, then binding it to a specific user. This is testing the candidate's understanding of Kubernetes _____.
RBAC (Role-Based Access Control) administration is a heavily weighted CKA domain ("Cluster Architecture, Installation & Configuration"). Candidates must be fluent in creating and binding Roles (namespace-scoped permissions) or ClusterRoles (cluster-wide permissions) to RoleBindings/ClusterRoleBindings, which attach those permissions to a ServiceAccount, user, or group.
RBAC vocabulary precision the exam expects:
Role vs. ClusterRole — a Role's permissions apply only within one namespace; a ClusterRole can apply cluster-wide or be reused across namespaces
RoleBinding vs. ClusterRoleBinding — a RoleBinding can reference either a Role or a ClusterRole, but still grants access scoped to its own namespace only, unless it's a ClusterRoleBinding
Verbs — "get", "list", "watch", "create", "update", "patch", "delete" — the exact permission granularity RBAC rules are written in
Subject — the User, Group, or ServiceAccount a binding grants access to
This is distinctly a CKA-domain topic — CKAD touches RBAC only lightly, since it is fundamentally a cluster-administration and security concern rather than an application-packaging one.
5 / 22
While preparing for CKA, a candidate reads that the exam is "open book" but with a specific restriction. What is that restriction, and why does it matter for exam strategy?
CKA's "open book" policy is narrower than the term might suggest to a non-native reader: only the official Kubernetes documentation (and a short list of explicitly permitted Kubernetes-affiliated pages) may be referenced — not Google, not Stack Overflow, not personal cheat sheets. This is a frequently misunderstood phrase, since "open book" in everyday English can imply "any reference material allowed."
Why the exact scope matters for exam strategy: because time is scarce (2 hours for 15–20 tasks) and only kubernetes.io is searchable, experienced CKA candidates memorise where in the docs to find specific command syntax (e.g. bookmarking the "kubectl Cheat Sheet" page) rather than memorising the syntax perfectly from scratch — a study strategy explicitly built around this narrow open-book rule. Misreading "open book" as "any resource allowed" is a real risk during the exam itself, since attempting to open a disallowed site can trigger a proctor warning.
6 / 22
During a code review of a new deployment script for our microservices, Sarah notes that the script uses `kubectl scale` to adjust the number of replicas for the 'payment-service' pod. Mark replies, 'Sounds good – just make sure it's scaling *up* and not down!'. Sarah responds with, 'I considered using a Horizontal Pod Autoscaler (HPA) instead. It would dynamically adjust based on CPU utilization.' What is the primary reason Sarah advocated for an HPA over `kubectl scale`?
The core difference lies in dynamic vs. static scaling. While `kubectl scale` provides immediate control, it requires manual intervention and doesn't adapt to changing workloads. An HPA continuously monitors resource utilization (typically CPU) and automatically adjusts the number of replicas – a far more robust approach for handling unpredictable traffic patterns in a microservices environment. Using HPAs aligns with best practices for Kubernetes autoscaling strategies.
7 / 22
During a post-mortem meeting for a recent service outage, David explains that the root cause was 'a misconfiguration in our deployment.' Maria pushes back, stating, 'That's too vague. Can you elaborate on *what* specifically was misconfigured – was it network policies, resource limits, or something else?' Which of the following best describes the key difference between David's initial statement and Maria's request for more detail?
David's initial response is high-level and doesn't provide actionable insight. A post-mortem aims to pinpoint the precise technical issue that led to the outage – in this case, a misconfiguration. Maria's question correctly pushes for specificity, reflecting a crucial aspect of effective troubleshooting and root cause analysis within Kubernetes environments. The key difference lies in shifting from acknowledging a symptom (the outage) to demanding a detailed explanation of the contributing technical factor.
8 / 22
During a discussion about scaling our e-commerce microservices, John suggests manually increasing the number of replicas for the 'checkout' service using `kubectl scale`. Lisa counters with, 'Let's use an HPA instead. It will automatically adjust based on traffic patterns.' Which of the following BEST describes the core benefit Lisa is emphasizing when advocating for a Horizontal Pod Autoscaler (HPA)?
The correct answer is B. Lisa's point centers on the *dynamic* nature of HPA – it continuously monitors metrics (like CPU utilization or requests per second) and automatically adjusts replica counts to maintain desired performance levels. Manual scaling requires constant monitoring and intervention, making it less responsive to unexpected traffic surges. Option A describes a benefit of manual control, not the primary advantage of an HPA.
9 / 22
During a code review of a new deployment script for our microservices, Sarah notes that the script uses `kubectl scale` to adjust the number of replicas for the 'payment-service' pod. Mark replies, 'Sounds good – just make sure it's scaling *up* and not down!'. Sarah responds with, 'I considered using a Horizontal Pod Autoscaler (HPA) instead. It would dynamically adjust based on CPU utilization.' What is the primary reason Sarah advocated for an HPA over `kubectl scale`?
The core difference lies in dynamic vs. static scaling. While `kubectl scale` provides immediate control, it requires manual intervention and doesn't adapt to changing workloads. An HPA continuously monitors resource utilization (typically CPU) and automatically adjusts the number of replicas – a far more robust approach for handling unpredictable traffic patterns in a microservices environment. Using HPAs aligns with best practices for Kubernetes autoscaling strategies.
10 / 22
During a post-mortem meeting for a recent service outage, David explains that the root cause was 'a misconfiguration in our deployment.' Maria pushes back, stating, 'That's too vague. Can you elaborate on *what* specifically was misconfigured – was it network policies, resource limits, or something else?' Which of the following best describes the key difference between David's initial statement and Maria's request for more detail?
David's initial response is high-level and doesn't provide actionable insight. A post-mortem aims to pinpoint the precise technical issue that led to the outage – in this case, a misconfiguration. Maria's question correctly pushes for specificity, reflecting a crucial aspect of effective troubleshooting and root cause analysis within Kubernetes environments. The key difference lies in shifting from acknowledging a symptom (the outage) to demanding a detailed explanation of the contributing technical factor.
11 / 22
During a discussion about scaling our e-commerce microservices, John suggests manually increasing the number of replicas for the 'checkout' service using `kubectl scale`. Lisa counters with, 'Let's use an HPA instead. It will automatically adjust based on traffic patterns.' Which of the following BEST describes the core benefit Lisa is emphasizing when advocating for a Horizontal Pod Autoscaler (HPA)?
The correct answer is B. Lisa's point centers on the *dynamic* nature of HPA – it continuously monitors metrics (like CPU utilization or requests per second) and automatically adjusts replica counts to maintain desired performance levels. Manual scaling requires constant monitoring and intervention, making it less responsive to unexpected traffic surges. Option A describes a benefit of manual control, not the primary advantage of an HPA.
12 / 22
During a code review of a new deployment script for our microservices, Sarah notes that the script uses `kubectl scale` to adjust the number of replicas for the 'payment-service' pod. Mark replies, 'Sounds good – just make sure it's scaling *up* and not down!'. Sarah responds with, 'I considered using a Horizontal Pod Autoscaler (HPA) instead. It would dynamically adjust based on CPU utilization.' What is the primary reason Sarah advocated for an HPA over `kubectl scale`?
The core difference lies in dynamic vs. static scaling. While `kubectl scale` provides immediate control, it requires manual intervention and doesn't adapt to changing workloads. An HPA continuously monitors resource utilization (typically CPU) and automatically adjusts the number of replicas – a far more robust approach for handling unpredictable traffic patterns in a microservices environment. Using HPAs aligns with best practices for Kubernetes autoscaling strategies.
13 / 22
During a post-mortem meeting for a recent service outage, David explains that the root cause was 'a misconfiguration in our deployment.' Maria pushes back, stating, 'That's too vague. Can you elaborate on *what* specifically was misconfigured – was it network policies, resource limits, or something else?' Which of the following best describes the key difference between David's initial statement and Maria's request for more detail?
David's initial response is high-level and doesn't provide actionable insight. A post-mortem aims to pinpoint the precise technical issue that led to the outage – in this case, a misconfiguration. Maria's question correctly pushes for specificity, reflecting a crucial aspect of effective troubleshooting and root cause analysis within Kubernetes environments. The key difference lies in shifting from acknowledging a symptom (the outage) to demanding a detailed explanation of the contributing technical factor.
14 / 22
During a discussion about scaling our e-commerce microservices, John suggests manually increasing the number of replicas for the 'checkout' service using `kubectl scale`. Lisa counters with, 'Let's use an HPA instead. It will automatically adjust based on traffic patterns.' Which of the following BEST describes the core benefit Lisa is emphasizing when advocating for a Horizontal Pod Autoscaler (HPA)?
The correct answer is B. Lisa's point centers on the *dynamic* nature of HPA – it continuously monitors metrics (like CPU utilization or requests per second) and automatically adjusts replica counts to maintain desired performance levels. Manual scaling requires constant monitoring and intervention, making it less responsive to unexpected traffic surges. Option A describes a benefit of manual control, not the primary advantage of an HPA.
15 / 22
During a code review of a new deployment script for our microservices, Sarah notes that the script uses `kubectl scale` to adjust the number of replicas for the 'payment-service' pod. Mark replies, 'Sounds good – just make sure it's scaling *up* and not down!'. Sarah responds with, 'I considered using a Horizontal Pod Autoscaler (HPA) instead. It would dynamically adjust based on CPU utilization.' What is the primary reason Sarah advocated for an HPA over `kubectl scale`?
The core difference lies in dynamic vs. static scaling. While `kubectl scale` provides immediate control, it requires manual intervention and doesn't adapt to changing workloads. An HPA continuously monitors resource utilization (typically CPU) and automatically adjusts the number of replicas – a far more robust approach for handling unpredictable traffic patterns in a microservices environment. Using HPAs aligns with best practices for Kubernetes autoscaling strategies.
16 / 22
During a post-mortem meeting for a recent service outage, David explains that the root cause was 'a misconfiguration in our deployment.' Maria pushes back, stating, 'That's too vague. Can you elaborate on *what* specifically was misconfigured – was it network policies, resource limits, or something else?' Which of the following best describes the key difference between David's initial statement and Maria's request for more detail?
David's initial response is high-level and doesn't provide actionable insight. A post-mortem aims to pinpoint the precise technical issue that led to the outage – in this case, a misconfiguration. Maria's question correctly pushes for specificity, reflecting a crucial aspect of effective troubleshooting and root cause analysis within Kubernetes environments. The key difference lies in shifting from acknowledging a symptom (the outage) to demanding a detailed explanation of the contributing technical factor.
17 / 22
During a discussion about scaling our e-commerce microservices, John suggests manually increasing the number of replicas for the 'checkout' service using `kubectl scale`. Lisa counters with, 'Let's use an HPA instead. It will automatically adjust based on traffic patterns.' Which of the following BEST describes the core benefit Lisa is emphasizing when advocating for a Horizontal Pod Autoscaler (HPA)?
The correct answer is B. Lisa's point centers on the *dynamic* nature of HPA – it continuously monitors metrics (like CPU utilization or requests per second) and automatically adjusts replica counts to maintain desired performance levels. Manual scaling requires constant monitoring and intervention, making it less responsive to unexpected traffic surges. Option A describes a benefit of manual control, not the primary advantage of an HPA.
18 / 22
Mark, a senior engineer, sends this Slack message to the team: 'The pod is stuck in Pending. Let's investigate!' What does Mark *most likely* mean when using the term 'stuck in Pending'?
'Stuck in Pending' indicates the Kubernetes scheduler hasn't found a suitable node to run the pod on. This typically means the pod requires resources (CPU, memory) that aren't available across the cluster, or there are scheduling constraints preventing its placement. It's not simply 'running' or related to network issues; it signifies a blockage at the scheduling level.
19 / 22
During a PR review, Alex comments on a YAML file: 'The `resources` section for this deployment should explicitly define the memory limits for each container using units like `Mi` or `Gi`.'. What is Alex referring to?
'Resources' in Kubernetes refers specifically to the limits and requests for CPU and memory that a container can consume. Using units like `Mi` (mebibytes) or `Gi` (gibibytes) is standard practice for defining these resource constraints precisely. It's not about quotas, dynamic allocation, core count, or storage.
20 / 22
In a standup meeting, Emily states: 'I'm working on updating the deployment manifest to use a Horizontal Pod Autoscaler (HPA).'. What is the primary *benefit* of using an HPA in this scenario?
An HPA dynamically scales the number of pods in a deployment based on real-time metrics like CPU usage. This ensures optimal resource utilization and responsiveness to changes in demand. Fixed replicas are managed by other methods (like Kubernetes deployments), manual scaling is not part of an HPA's function, and strict limits are set via resource requests/limits.
21 / 22
A developer, David, is writing a PR description for a new deployment. He includes the following: 'We've scaled the 'api' service to 5 replicas using kubectl scale -n api --replicas=5'. What does this command *primarily* achieve?
The `kubectl scale` command with `--replicas=5` instructs Kubernetes to temporarily increase the number of replicas for the 'api' service. This change is not persistent and will likely be reverted upon a pod restart or deployment update unless explicitly configured otherwise. It doesn't create a new deployment, permanently alter the service, or automatically scale based on metrics.
22 / 22
During a troubleshooting session, Liam says, 'The application is timing out when attempting to connect to the database. We need to investigate if there are any network policies preventing access.' What aspect of Kubernetes is Liam focusing on?
Network policies in Kubernetes control network traffic flow between pods. If an application is timing out when connecting to a database, it suggests a potential issue with network connectivity governed by Network Policies or other network security controls. Resource limits and storage classes are separate concerns; health checks relate to application availability.
What will I practice in "CKA (Certified Kubernetes Administrator) Vocabulary — Exam Language"?
This is a Certification Prep exercise set. It walks through 22 scenario-based multiple-choice questions built around real usage of Certification Prep terminology that IT professionals encounter on the job.
Is this exercise free to use?
Yes. Every exercise on CoderSlingo, including this one, is free to complete with no account, sign-up, or paywall.
How many questions are in this exercise?
This set contains 22 questions. Each one shows immediate feedback and a detailed explanation after you answer, so you learn the correct usage right away rather than waiting for a final score.
Do I need prior experience to complete this exercise?
No prior experience is required. Each question includes a full explanation covering the reasoning behind the correct answer, so the exercise itself teaches the Certification Prep vocabulary as you go.
Can I retry the exercise if I get questions wrong?
Yes — use the "Try again" button on the results screen to reset your answers and go through all the questions again. There is no limit on attempts.
Is my progress saved?
Your answers and score for the current session are tracked in the browser as you go. No account or login is needed, and there is nothing to install.
What if I don't understand a term used in a question?
Read the explanation shown after you answer each question — it breaks down the correct term in plain English with a real-world example. You can also check the site Glossary for quick definitions.
How is this different from reading a blog article on the topic?
Exercises like this one are interactive drills that test and reinforce specific vocabulary through multiple-choice questions, while blog articles explain concepts in prose. Practising here after reading builds active recall, not just passive recognition.
Where can I find more Certification Prep exercises?
See the Certification Prep exercises hub for the full set of related pages, or browse all exercise categories from the main Exercises index.
Can I use this exercise to prepare for a technical interview?
Yes — Certification Prep vocabulary comes up often in technical discussions and interviews. Pair this exercise with our dedicated Interview Preparation section for role-specific practice.