5 exercises — CKAD vs. CKA scope, sidecar/ambassador/adapter design patterns, ConfigMaps vs. Secrets, liveness/readiness/startup probes, and Job vs. CronJob. CKAD's application-developer vocabulary, distinct from CKA's cluster-administration focus.
Why precise CKAD vocabulary matters
Application-developer scope — building/deploying apps, not administering the cluster
Multi-container patterns — sidecar, ambassador, adapter are three distinct, testable patterns
ConfigMap vs. Secret — non-sensitive vs. sensitive configuration injection
Liveness vs. readiness vs. startup probe — restart vs. traffic-routing vs. slow-start handling
Job/CronJob vs. Deployment/DaemonSet — run-to-completion vs. continuous vs. per-node workloads
0 / 25 completed
1 / 25
CKAD and CKA share the same hands-on, terminal-based exam format and are both administered by CNCF. What is the core difference in what each exam tests, and why would a job posting specify one over the other?
Both exams share the same 100% performance-based, hands-on terminal format and 2-hour time limit administered by the Linux Foundation/CNCF, but they test genuinely different job functions. CKA is the platform/infrastructure-engineer exam (own and operate the cluster). CKAD is the application-developer exam (build and ship workloads correctly onto a cluster someone else manages).
2-hour exam, roughly 15–20 tasks, same killer.sh practice simulator as CKA
Open book — kubernetes.io documentation only, same narrow rule as CKA
Renewal every 3 years through CNCF
CKAD is not a prerequisite-gated exam — it can be taken independently of CKA, and many application developers take only CKAD without ever needing CKA
Job postings that list "CKAD preferred" rather than "CKA preferred" are signalling they want application-layer Kubernetes fluency, not cluster-operations responsibility — a distinction worth recognising when reading job requirements in English.
2 / 25
A CKAD task requires designing a Pod where a small helper container continuously ships logs from a shared volume to an external system, running alongside the main application container for its entire lifecycle. Which multi-container pod design pattern does this describe?
The sidecar pattern is a core CKAD design-pattern topic: a secondary container that runs for the entire lifetime of the pod alongside the main application container, typically sharing a volume or network namespace to extend functionality (log shipping, in this example) without modifying the main container's image.
The three multi-container patterns CKAD explicitly names, and how to tell them apart:
Sidecar — runs continuously alongside the main container, extending its behaviour (log shipping, file syncing)
Ambassador — a proxy that simplifies the main container's outbound connections to external services (e.g. handling retries or service discovery on its behalf)
Adapter — standardises or transforms the main container's output into a common format for external tools (e.g. converting custom app metrics into a Prometheus-compatible format)
Separately, an init container runs before the main container starts and must complete successfully first — it is not a "pattern" of ongoing collaboration but a sequencing mechanism, and is the most common wrong answer offered as a distractor for sidecar questions since both involve "extra containers in one pod."
3 / 25
A CKAD task asks the candidate to inject application configuration (a database URL, a feature flag) into a running container without rebuilding the container image, and to keep sensitive values like an API key separate from non-sensitive settings. Which two Kubernetes objects does this scenario require, and what is the key difference between them?
ConfigMaps and Secrets are core CKAD "Application Design and Build" domain objects, and the exam tests precise knowledge of when to use each and how to inject them (as environment variables via envFrom/valueFrom, or as mounted volumes). The critical distinction: Secrets are intended for sensitive data (though base64 encoding is not encryption — a common exam-adjacent gotcha for security awareness), while ConfigMaps are for ordinary, non-sensitive configuration.
Related CKAD vocabulary on the same topic:
envFrom — inject an entire ConfigMap/Secret's keys as environment variables at once
volumeMounts with a ConfigMap/Secret volume — expose configuration as files inside the container instead of environment variables, useful when an app expects a config file rather than env vars
Immutable ConfigMaps/Secrets — a field that prevents accidental updates, tested as a best-practice option
This decoupling of configuration from the image is a fundamental "twelve-factor app" principle CKAD assumes candidates already understand conceptually, then tests the exact Kubernetes mechanics of implementing it.
4 / 25
A CKAD task configures a container so that Kubernetes automatically restarts it if it becomes unresponsive, but only routes traffic to it once it has finished its startup work and is actually able to serve requests. These two checks are called the _____ probe and the _____ probe, respectively.
The liveness probe answers "is this container still alive/healthy, or should Kubernetes restart it?" The readiness probe answers "is this container ready to receive traffic right now?" — a container can be alive (liveness passes) but not yet ready (still loading a cache, warming up a connection pool), in which case the Service should not route traffic to it yet even though it shouldn't be restarted.
The full probe vocabulary CKAD tests (a dedicated exam domain, "Application Observability and Maintenance"):
Liveness probe — failing repeatedly triggers a container restart
Readiness probe — failing removes the pod from a Service's endpoints (no traffic routed), without restarting anything
Startup probe — used for slow-starting containers, delays liveness/readiness checks until the app has genuinely finished initialising, preventing a slow-but-healthy app from being killed prematurely by an impatient liveness probe
Exam scenarios frequently describe symptoms ("the pod keeps restarting even though the app eventually starts fine") that require recognising a missing startup probe as the root cause — precise vocabulary distinguishes "restart" (liveness) from "removed from load balancing" (readiness) symptoms.
5 / 25
A CKAD task requires a job that runs a data-cleanup script every night at 2 AM, retrying up to 3 times if it fails, and a separate one-off script that must run exactly once during a deployment to migrate a database schema. Which two Kubernetes objects match each requirement?
A Job runs one or more pods to completion — ideal for a one-off task like a database migration — and can be configured with completions and parallelism for more complex batch patterns. A CronJob wraps a Job with a schedule (standard cron syntax, e.g. 0 2 * * * for 2 AM daily), automatically creating a new Job run at each scheduled time.
Precise CKAD vocabulary around these workload types:
backoffLimit — the number of retries a Job attempts before being marked failed
restartPolicy — for Jobs/CronJobs, must be Never or OnFailure (never Always, which is only valid for long-running workloads like Deployments)
Deployment — for long-running, stateless, continuously-serving workloads (not "run once and stop")
DaemonSet — ensures exactly one copy of a pod runs on every (or selected) node, used for node-level agents like log collectors, not scheduled batch work
Distinguishing "runs to completion" (Job/CronJob) from "runs continuously" (Deployment) from "runs once per node" (DaemonSet) is a foundational CKAD vocabulary distinction that recurs across multiple exam tasks.
6 / 25
During a code review of a pull request for a new microservice deployed to Kubernetes, Sarah comments: 'The service is failing intermittently. The logs show 'Error: Connection refused' when attempting to reach the database. We should investigate if the database pod is healthy and receiving traffic.' Which of the following best describes Sarah's intent regarding monitoring the database pod?
kubectl describe pod my-db-pod
Sarah's comment highlights her focus on understanding *why* the service is failing. The 'Error: Connection refused' suggests a problem reaching the database, not necessarily a general application error. Liveness probes are designed to monitor if a container is running and receiving traffic – this is precisely what Sarah needs to determine before assuming a deeper issue exists. Options A, C, and D represent actions focused on other aspects of troubleshooting or deployment configuration, rather than directly assessing the health and availability of the database pod as Sarah intended.
7 / 25
PR Description:
As part of the rollout of our new payment processing service, we've deployed a Kubernetes cluster and are using ConfigMaps to manage environment variables. We need to ensure that the service can reliably handle peak loads during promotional periods. The current configuration uses an HPA (Horizontal Pod Autoscaler) based on CPU utilization, but we're concerned this might lead to excessive scaling and resource contention.
Which of the following strategies would MOST effectively mitigate these concerns and improve the stability of the payment processing service under heavy load?
The correct answer (HPA based on custom metrics) addresses the core concern of proactive scaling. The HPA currently only reacts to CPU usage, which isn't always a reliable indicator of demand for a payment processing service – high CPU could be due to inefficient code, not necessarily increased transactions. Using custom metrics allows Kubernetes to respond more accurately to actual workload pressure, preventing over-scaling and resource contention. Options B, C, and D are less effective; manually adjusting replicas is inflexible, disabling the HPA removes an automated safety net, and a rolling update doesn't directly address the scaling challenge itself.
8 / 25
David: "Hey team, I'm seeing a high error rate in the API gateway logs. The service is returning 502 Bad Gateway errors intermittently. We've recently upgraded the backend microservice version, so it could be related. Can someone check the gateway metrics and recent deployments?"
David's comment highlights a critical issue: intermittent 502 Bad Gateway errors. The most logical first step is to investigate recent deployments and correlate the errors with specific versions or configuration changes – particularly focusing on the recently upgraded backend microservice. Increasing replicas (option B) might mask the underlying problem, while circuit breakers (option A) are generally applied at a higher level of abstraction and aren't immediately relevant to initial troubleshooting. Rolling back (option D) is premature without understanding the root cause.
9 / 25
During a code review of a pull request for a new microservice deployed to Kubernetes, Maria comments: 'We're seeing increased latency in the user interface. The service logs indicate high CPU utilization within the container. Let's investigate if the resource requests are correctly defined and if we're hitting any bottlenecks.' Considering this scenario, which command would be MOST useful for Maria to quickly diagnose the issue?
The correct answer is `kubectl top pods -n my-service`. This command directly displays real-time CPU and memory usage for the specified pod (identified by its name), providing immediate insight into the high CPU utilization Maria observed. The other options are less targeted: `describe events` shows system events, not resource consumption; `logs -f` only provides log data, potentially masking underlying problems like resource constraints, and `insufficient` is a placeholder indicating a lack of information.
10 / 25
You're reviewing a PR for a new Kubernetes deployment. The developer has implemented a liveness probe on the application container to monitor its health. During your review, you notice the probe is configured to check if the container is running. However, you suspect the probe might be too simplistic and not capture more critical issues. What's the primary reason you'd advise the developer to consider using a different type of probe?
The core purpose of a liveness probe is to determine if an application within a container is still functioning correctly. Simply checking if the container is running doesn't guarantee that the application itself is healthy – it could be stuck in a loop, consuming excessive resources, or experiencing internal errors. A more sophisticated probe (like a readiness probe) would check for application-specific conditions, ensuring the Kubernetes scheduler only routes traffic to fully functional pods. This prevents wasted effort and potential downtime.
11 / 25
During a code review of a pull request for a new microservice deployed to Kubernetes, Sarah comments: 'The service is failing intermittently. The logs show 'Error: Connection refused' when attempting to reach the database. We should investigate if the database pod is healthy and receiving traffic.' Which of the following best describes Sarah's intent regarding monitoring the database pod?
kubectl describe pod my-db-pod
Sarah's comment highlights her focus on understanding *why* the service is failing. The 'Error: Connection refused' suggests a problem reaching the database, not necessarily a general application error. Liveness probes are designed to monitor if a container is running and receiving traffic – this is precisely what Sarah needs to determine before assuming a deeper issue exists. Options A, C, and D represent actions focused on other aspects of troubleshooting or deployment configuration, rather than directly assessing the health and availability of the database pod as Sarah intended.
12 / 25
PR Description:
As part of the rollout of our new payment processing service, we've deployed a Kubernetes cluster and are using ConfigMaps to manage environment variables. We need to ensure that the service can reliably handle peak loads during promotional periods. The current configuration uses an HPA (Horizontal Pod Autoscaler) based on CPU utilization, but we're concerned this might lead to excessive scaling and resource contention.
Which of the following strategies would MOST effectively mitigate these concerns and improve the stability of the payment processing service under heavy load?
The correct answer (HPA based on custom metrics) addresses the core concern of proactive scaling. The HPA currently only reacts to CPU usage, which isn't always a reliable indicator of demand for a payment processing service – high CPU could be due to inefficient code, not necessarily increased transactions. Using custom metrics allows Kubernetes to respond more accurately to actual workload pressure, preventing over-scaling and resource contention. Options B, C, and D are less effective; manually adjusting replicas is inflexible, disabling the HPA removes an automated safety net, and a rolling update doesn't directly address the scaling challenge itself.
13 / 25
David: "Hey team, I'm seeing a high error rate in the API gateway logs. The service is returning 502 Bad Gateway errors intermittently. We've recently upgraded the backend microservice version, so it could be related. Can someone check the gateway metrics and recent deployments?"
David's comment highlights a critical issue: intermittent 502 Bad Gateway errors. The most logical first step is to investigate recent deployments and correlate the errors with specific versions or configuration changes – particularly focusing on the recently upgraded backend microservice. Increasing replicas (option B) might mask the underlying problem, while circuit breakers (option A) are generally applied at a higher level of abstraction and aren't immediately relevant to initial troubleshooting. Rolling back (option D) is premature without understanding the root cause.
14 / 25
During a code review of a pull request for a new microservice deployed to Kubernetes, Maria comments: 'We're seeing increased latency in the user interface. The service logs indicate high CPU utilization within the container. Let's investigate if the resource requests are correctly defined and if we're hitting any bottlenecks.' Considering this scenario, which command would be MOST useful for Maria to quickly diagnose the issue?
The correct answer is `kubectl top pods -n my-service`. This command directly displays real-time CPU and memory usage for the specified pod (identified by its name), providing immediate insight into the high CPU utilization Maria observed. The other options are less targeted: `describe events` shows system events, not resource consumption; `logs -f` only provides log data, potentially masking underlying problems like resource constraints, and `insufficient` is a placeholder indicating a lack of information.
15 / 25
You're reviewing a PR for a new Kubernetes deployment. The developer has implemented a liveness probe on the application container to monitor its health. During your review, you notice the probe is configured to check if the container is running. However, you suspect the probe might be too simplistic and not capture more critical issues. What's the primary reason you'd advise the developer to consider using a different type of probe?
The core purpose of a liveness probe is to determine if an application within a container is still functioning correctly. Simply checking if the container is running doesn't guarantee that the application itself is healthy – it could be stuck in a loop, consuming excessive resources, or experiencing internal errors. A more sophisticated probe (like a readiness probe) would check for application-specific conditions, ensuring the Kubernetes scheduler only routes traffic to fully functional pods. This prevents wasted effort and potential downtime.
16 / 25
During a code review of a pull request for a new microservice deployed to Kubernetes, Sarah comments: 'The service is failing intermittently. The logs show 'Error: Connection refused' when attempting to reach the database. We should investigate if the database pod is healthy and receiving traffic.' Which of the following best describes Sarah's intent regarding monitoring the database pod?
kubectl describe pod my-db-pod
Sarah's comment highlights her focus on understanding *why* the service is failing. The 'Error: Connection refused' suggests a problem reaching the database, not necessarily a general application error. Liveness probes are designed to monitor if a container is running and receiving traffic – this is precisely what Sarah needs to determine before assuming a deeper issue exists. Options A, C, and D represent actions focused on other aspects of troubleshooting or deployment configuration, rather than directly assessing the health and availability of the database pod as Sarah intended.
17 / 25
PR Description:
As part of the rollout of our new payment processing service, we've deployed a Kubernetes cluster and are using ConfigMaps to manage environment variables. We need to ensure that the service can reliably handle peak loads during promotional periods. The current configuration uses an HPA (Horizontal Pod Autoscaler) based on CPU utilization, but we're concerned this might lead to excessive scaling and resource contention.
Which of the following strategies would MOST effectively mitigate these concerns and improve the stability of the payment processing service under heavy load?
The correct answer (HPA based on custom metrics) addresses the core concern of proactive scaling. The HPA currently only reacts to CPU usage, which isn't always a reliable indicator of demand for a payment processing service – high CPU could be due to inefficient code, not necessarily increased transactions. Using custom metrics allows Kubernetes to respond more accurately to actual workload pressure, preventing over-scaling and resource contention. Options B, C, and D are less effective; manually adjusting replicas is inflexible, disabling the HPA removes an automated safety net, and a rolling update doesn't directly address the scaling challenge itself.
18 / 25
David: "Hey team, I'm seeing a high error rate in the API gateway logs. The service is returning 502 Bad Gateway errors intermittently. We've recently upgraded the backend microservice version, so it could be related. Can someone check the gateway metrics and recent deployments?"
David's comment highlights a critical issue: intermittent 502 Bad Gateway errors. The most logical first step is to investigate recent deployments and correlate the errors with specific versions or configuration changes – particularly focusing on the recently upgraded backend microservice. Increasing replicas (option B) might mask the underlying problem, while circuit breakers (option A) are generally applied at a higher level of abstraction and aren't immediately relevant to initial troubleshooting. Rolling back (option D) is premature without understanding the root cause.
19 / 25
During a code review of a pull request for a new microservice deployed to Kubernetes, Maria comments: 'We're seeing increased latency in the user interface. The service logs indicate high CPU utilization within the container. Let's investigate if the resource requests are correctly defined and if we're hitting any bottlenecks.' Considering this scenario, which command would be MOST useful for Maria to quickly diagnose the issue?
The correct answer is `kubectl top pods -n my-service`. This command directly displays real-time CPU and memory usage for the specified pod (identified by its name), providing immediate insight into the high CPU utilization Maria observed. The other options are less targeted: `describe events` shows system events, not resource consumption; `logs -f` only provides log data, potentially masking underlying problems like resource constraints, and `insufficient` is a placeholder indicating a lack of information.
20 / 25
You're reviewing a PR for a new Kubernetes deployment. The developer has implemented a liveness probe on the application container to monitor its health. During your review, you notice the probe is configured to check if the container is running. However, you suspect the probe might be too simplistic and not capture more critical issues. What's the primary reason you'd advise the developer to consider using a different type of probe?
The core purpose of a liveness probe is to determine if an application within a container is still functioning correctly. Simply checking if the container is running doesn't guarantee that the application itself is healthy – it could be stuck in a loop, consuming excessive resources, or experiencing internal errors. A more sophisticated probe (like a readiness probe) would check for application-specific conditions, ensuring the Kubernetes scheduler only routes traffic to fully functional pods. This prevents wasted effort and potential downtime.
21 / 25
During a code review of a pull request for a new microservice deployed to Kubernetes, Sarah comments: 'The service is failing intermittently. The logs show 'Error: Connection refused' when attempting to reach the database. We should investigate if the database pod is healthy and receiving traffic.' Which of the following best describes Sarah's intent regarding monitoring the database pod?
kubectl describe pod my-db-pod
Sarah's comment highlights her focus on understanding *why* the service is failing. The 'Error: Connection refused' suggests a problem reaching the database, not necessarily a general application error. Liveness probes are designed to monitor if a container is running and receiving traffic – this is precisely what Sarah needs to determine before assuming a deeper issue exists. Options A, C, and D represent actions focused on other aspects of troubleshooting or deployment configuration, rather than directly assessing the health and availability of the database pod as Sarah intended.
22 / 25
PR Description:
As part of the rollout of our new payment processing service, we've deployed a Kubernetes cluster and are using ConfigMaps to manage environment variables. We need to ensure that the service can reliably handle peak loads during promotional periods. The current configuration uses an HPA (Horizontal Pod Autoscaler) based on CPU utilization, but we're concerned this might lead to excessive scaling and resource contention.
Which of the following strategies would MOST effectively mitigate these concerns and improve the stability of the payment processing service under heavy load?
The correct answer (HPA based on custom metrics) addresses the core concern of proactive scaling. The HPA currently only reacts to CPU usage, which isn't always a reliable indicator of demand for a payment processing service – high CPU could be due to inefficient code, not necessarily increased transactions. Using custom metrics allows Kubernetes to respond more accurately to actual workload pressure, preventing over-scaling and resource contention. Options B, C, and D are less effective; manually adjusting replicas is inflexible, disabling the HPA removes an automated safety net, and a rolling update doesn't directly address the scaling challenge itself.
23 / 25
David: "Hey team, I'm seeing a high error rate in the API gateway logs. The service is returning 502 Bad Gateway errors intermittently. We've recently upgraded the backend microservice version, so it could be related. Can someone check the gateway metrics and recent deployments?"
David's comment highlights a critical issue: intermittent 502 Bad Gateway errors. The most logical first step is to investigate recent deployments and correlate the errors with specific versions or configuration changes – particularly focusing on the recently upgraded backend microservice. Increasing replicas (option B) might mask the underlying problem, while circuit breakers (option A) are generally applied at a higher level of abstraction and aren't immediately relevant to initial troubleshooting. Rolling back (option D) is premature without understanding the root cause.
24 / 25
During a code review of a pull request for a new microservice deployed to Kubernetes, Maria comments: 'We're seeing increased latency in the user interface. The service logs indicate high CPU utilization within the container. Let's investigate if the resource requests are correctly defined and if we're hitting any bottlenecks.' Considering this scenario, which command would be MOST useful for Maria to quickly diagnose the issue?
The correct answer is `kubectl top pods -n my-service`. This command directly displays real-time CPU and memory usage for the specified pod (identified by its name), providing immediate insight into the high CPU utilization Maria observed. The other options are less targeted: `describe events` shows system events, not resource consumption; `logs -f` only provides log data, potentially masking underlying problems like resource constraints, and `insufficient` is a placeholder indicating a lack of information.
25 / 25
You're reviewing a PR for a new Kubernetes deployment. The developer has implemented a liveness probe on the application container to monitor its health. During your review, you notice the probe is configured to check if the container is running. However, you suspect the probe might be too simplistic and not capture more critical issues. What's the primary reason you'd advise the developer to consider using a different type of probe?
The core purpose of a liveness probe is to determine if an application within a container is still functioning correctly. Simply checking if the container is running doesn't guarantee that the application itself is healthy – it could be stuck in a loop, consuming excessive resources, or experiencing internal errors. A more sophisticated probe (like a readiness probe) would check for application-specific conditions, ensuring the Kubernetes scheduler only routes traffic to fully functional pods. This prevents wasted effort and potential downtime.
What will I practice in "CKAD (Certified Kubernetes Application Developer) Vocabulary — Exam Language"?
This is a Certification Prep exercise set. It walks through 25 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 25 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.