McAfee Secure

CNCF CKA Bundle

Exam Code: CKA

Exam Name Certified Kubernetes Administrator

Certification Provider: CNCF

Corresponding Certification: CKA

CNCF CKA Bundle $44.99
CKA Sample 1 CKA Sample 2 CKA Sample 3 CKA Sample 4 CKA Sample 5 CKA Sample 6 CKA Sample 7 CKA Sample 8 CKA Sample 9 CKA Sample 10

100% CNCF CKA Guaranteed Success With Testking Training Materials

Get Real CKA Exam Questions & Expert Verified Answers as Experienced on the Real Exam!

  • Questions & Answers

    CKA Questions & Answers

    58 Questions & Answers

    The ultimate exam preparation tool, Questions & Answers mirrors the actual CKA exam while allowing you to hone and measure every aspect of your test-taking ability.

  • CKA Video Course

    CKA Training Course

    138 Video Lectures

    CKA Video Course is developed by CNCF Professionals to help you pass the CKA exam.

    Description

    This course will improve your knowledge and skills required to pass Certified Kubernetes Administrator exam.
  • Study Guide

    CKA Study Guide

    268 PDF Pages

    Developed by industry experts, this 268-page guide spells out in painstaking detail all of the information you need to ace CKA exam.

Certified Kubernetes Administrator (CKA) Practice Tests

Satisfaction Guaranteed

Money Back Guarantee

Testking provides hassle-free money back guarantee with our products. That is because we have 100% trust in the abilities of our professional and experience product team, and our record is a proof of that.

99.6% PASS RATE
Total Cost: $194.97
Bundle Price: $149.98

Purchase Individually

  • Questions & Answers

    Questions & Answers

    58 Questions

    $124.99
  • CKA Video Course

    Training Course

    138 Video Lectures

    $39.99
  • Study Guide

    Study Guide

    268 PDF Pages

    $29.99

CNCF CKA Practice Test 31

Question 300

At Pinecrest logistics, in a sandbox Kubernetes cluster during a recovery tabletop exercise: A Kubernetes operator named dispatch-operator is installed in namespace fulfillment; verify controller and CRD presence before relying on custom resources. Work only within the stated target and verify before declaring success. Which operational control most directly prevents this failure or configuration drift?

  1. Manage namespace creation and required labels through version-controlled bootstrap manifests.
  2. Monitor operator controller availability and CRD conversion compatibility across upgrades.
  3. Schedule isolated restore drills, not just successful snapshot creation alerts.
  4. Record node maintenance ownership and uncordon obligations before opening a window.

Explanation

Correct Answer

B:

Monitor operator controller availability and CRD conversion compatibility across upgrades. This reduces recurrence of the specific operational failure. It reinforces the action: Run kubectl -n fulfillment rollout status deployment/dispatch-operator and kubectl get crd dispatches.example.test. The relevant mechanism is: Custom resources are reconciled only when their schemas are registered and the operator controller is healthy.

Incorrect Answers

A:

The suggested review tracks a different technical risk: A Namespace supplies a scope for namespaced resources while its metadata labels support policy and inventory selectors. Here the sustained control must address: Custom resources are reconciled only when their schemas are registered and the operator controller is healthy. Choose “Monitor operator controller availability and CRD conversion compatibility across upgrades”.

C:

This routine guards against another mechanism: The snapshot-status tool inspects backup metadata without modifying the running etcd member or performing a restore. The recurring exposure in the current case is: Custom resources are reconciled only when their schemas are registered and the operator controller is healthy. The matching preventive check is “Monitor operator controller availability and CRD conversion compatibility across upgrades”.

D:

The suggested review tracks a different technical risk: Cordon marks a Node unschedulable to new Pods but does not drain running workloads. Here the sustained control must address: Custom resources are reconciled only when their schemas are registered and the operator controller is healthy. Choose “Monitor operator controller availability and CRD conversion compatibility across upgrades”.

Question 301

At Northstar finance, in an isolated training cluster during a scheduled maintenance rehearsal: The Deployment invoice-api in namespace ledger must run exactly 3 replicas during a planned demand change. Work only within the stated target and verify before declaring success. Which command or initial safe diagnostic step best addresses the stated lab task?

  1. Run kubectl -n ledger patch deployment invoice-api --type=merge -p '{"spec":{"template":{"spec":{"tolerations":[{"key":"special","operator":"Equal","value":"dedicated","effect":"NoSchedule"}]}}}}' after checking existing tolerations.
  2. Run kubectl -n fulfillment rollout undo deployment/dispatch-api after checking rollout history.
  3. Run kubectl -n ledger set resources deployment/invoice-api --requests=cpu=250m --limits=memory=256Mi after verifying the Deployment's container selection.
  4. Run kubectl -n ledger scale deployment/invoice-api --replicas=3.

Explanation

Correct Answer

D:

Run kubectl -n ledger scale deployment/invoice-api --replicas=3. This is the appropriate command-line action or first safe diagnostic. The technical reason is: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state. Validate the result with: Run kubectl -n ledger rollout status deployment/invoice-api and kubectl -n ledger get deployment invoice-api to compare desired and ready counts. Execute changes only in an authorized disposable lab or after normal production change controls.

Incorrect Answers

A:

The offered action targets: A toleration allows a Pod past a matching taint but does not ensure placement without node selection and capacity. The case facts point instead to: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state. Implement “Run kubectl -n ledger scale deployment/invoice-api --replicas=3” to address that specific condition.

B:

This alternative is a response to another technical cause: A Deployment tracks ReplicaSet revisions and rollout undo restores a recorded earlier Pod template. The reported case instead depends on: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state. The action that directly addresses it is “Run kubectl -n ledger scale deployment/invoice-api --replicas=3”.

C:

The proposed action belongs to the mechanism: Requests inform scheduling and limits cap runtime consumption; the settings play different roles. Here the stated fault follows a different mechanism: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state. The corrective choice is “Run kubectl -n ledger scale deployment/invoice-api --replicas=3”.

Question 302

At Northstar finance, in an isolated training cluster during a scheduled maintenance rehearsal: The Deployment invoice-api in namespace ledger must run exactly 3 replicas during a planned demand change. Work only within the stated target and verify before declaring success. Which Kubernetes behavior best explains the required change or diagnosis?

  1. Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state.
  2. Environment variables are copied into new container processes from ConfigMap values; existing running processes need replacement to pick up changes.
  3. HPA evaluates metrics relative to Pod resource requests; missing metrics or requests can leave desired replicas unknown.
  4. Updating a Deployment Pod template triggers a controlled rollout; restarting Pods alone will not change the image reference.

Explanation

Correct Answer

A:

Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state. This explains the stated condition. The corresponding action is: Run kubectl -n ledger scale deployment/invoice-api --replicas=3. The direct acceptance evidence is: Run kubectl -n ledger rollout status deployment/invoice-api and kubectl -n ledger get deployment invoice-api to compare desired and ready counts.

Incorrect Answers

B:

Environment variables are copied into new container processes from ConfigMap values; existing running processes need replacement to pick up changes. That explanation applies to a different technical failure. Here the controlling principle is: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state.

C:

The offered statement is true for this other mechanism: HPA evaluates metrics relative to Pod resource requests; missing metrics or requests can leave desired replicas unknown. It does not explain the facts described here, which follow from: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state.

D:

This principle describes a separate cause: Updating a Deployment Pod template triggers a controlled rollout; restarting Pods alone will not change the image reference. The reported condition is governed by: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state. The two mechanisms should not be conflated.

Question 303

At Northstar finance, in an isolated training cluster during a scheduled maintenance rehearsal: The Deployment invoice-api in namespace ledger must run exactly 3 replicas during a planned demand change. Work only within the stated target and verify before declaring success. Which observation best verifies the requested outcome rather than an unrelated state?

  1. Run kubectl -n ledger get cronjob daily-archive -o jsonpath='{.spec.suspend}' and verify true.
  2. Run kubectl -n ledger rollout status deployment/invoice-api and kubectl -n ledger get deployment invoice-api to compare desired and ready counts.
  3. Run kubectl -n ledger rollout status deployment/invoice-api and inspect new Pod creation timestamps.
  4. Run kubectl -n fulfillment rollout status deployment/dispatch-api and inspect the restored image and configuration.

Explanation

Correct Answer

B:

Run kubectl -n ledger rollout status deployment/invoice-api and kubectl -n ledger get deployment invoice-api to compare desired and ready counts. This validates the affected object or control path, rather than only showing a command completed. The underlying reason is: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state. The intended action is: Run kubectl -n ledger scale deployment/invoice-api --replicas=3.

Incorrect Answers

A:

The alternative verifies a different condition: CronJob suspension prevents new scheduled Jobs but does not terminate existing Jobs already running. The current case instead depends on: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state. Confirm that “Run kubectl -n ledger rollout status deployment/invoice-api and kubectl -n ledger get deployment invoice-api to compare desired and ready counts”.

C:

This observation would test a different technical dependency: Rollout restart annotates the Pod template so the Deployment controller replaces Pods according to its rollout strategy. The current issue is governed by: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state. Its decisive check is “Run kubectl -n ledger rollout status deployment/invoice-api and kubectl -n ledger get deployment invoice-api to compare desired and ready counts”.

D:

The alternative verifies a different condition: A Deployment tracks ReplicaSet revisions and rollout undo restores a recorded earlier Pod template. The current case instead depends on: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state. Confirm that “Run kubectl -n ledger rollout status deployment/invoice-api and kubectl -n ledger get deployment invoice-api to compare desired and ready counts”.

Question 304

At Northstar finance, in an isolated training cluster during a scheduled maintenance rehearsal: The Deployment invoice-api in namespace ledger must run exactly 3 replicas during a planned demand change. Work only within the stated target and verify before declaring success. Which operational control most directly prevents this failure or configuration drift?

  1. Treat taints and tolerations as paired scheduling controls and review preexisting tolerations when patching arrays.
  2. For production use protected secret-delivery workflows, RBAC and encryption-at-rest controls.
  3. Use reviewed scaling boundaries and monitor HPA ownership before manual replica changes.
  4. Gate deployment promotion on observed rollout and readiness rather than API command exit alone.

Explanation

Correct Answer

C:

Use reviewed scaling boundaries and monitor HPA ownership before manual replica changes. This reduces recurrence of the specific operational failure. It reinforces the action: Run kubectl -n ledger scale deployment/invoice-api --replicas=3. The relevant mechanism is: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state.

Incorrect Answers

A:

That safeguard is relevant to: A toleration allows a Pod past a matching taint but does not ensure placement without node selection and capacity. The current failure instead follows from: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state. Its prevention measure is “Use reviewed scaling boundaries and monitor HPA ownership before manual replica changes”.

B:

This routine guards against another mechanism: Kubernetes Secrets are API objects intended for sensitive values, but literals in a shell command can leak via shell history and process observation. The recurring exposure in the current case is: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state. The matching preventive check is “Use reviewed scaling boundaries and monitor HPA ownership before manual replica changes”.

D:

That safeguard is relevant to: A successful API mutation does not guarantee updated Pods are healthy and available; rollout status tracks controller progress. The current failure instead follows from: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state. Its prevention measure is “Use reviewed scaling boundaries and monitor HPA ownership before manual replica changes”.

Question 305

At Horizon observability, in a disposable simulated environment during a monitored release window: The Deployment metrics-api in namespace observability must run exactly 4 replicas during a planned demand change. Work only within the stated target and verify before declaring success. Which command or initial safe diagnostic step best addresses the stated lab task?

  1. Run kubectl -n observability scale deployment/metrics-api --replicas=4.
  2. Run kubectl -n fulfillment rollout undo deployment/dispatch-api after checking rollout history.
  3. Run kubectl -n observability set resources deployment/metrics-api --requests=cpu=400m --limits=memory=384Mi after verifying the Deployment's container selection.
  4. Run kubectl -n observability rollout status deployment/metrics-api --timeout=120s.

Explanation

Correct Answer

A:

Run kubectl -n observability scale deployment/metrics-api --replicas=4. This is the appropriate command-line action or first safe diagnostic. The technical reason is: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state. Validate the result with: Run kubectl -n observability rollout status deployment/metrics-api and kubectl -n observability get deployment metrics-api to compare desired and ready counts. Execute changes only in an authorized disposable lab or after normal production change controls.

Incorrect Answers

B:

The proposed action belongs to the mechanism: A Deployment tracks ReplicaSet revisions and rollout undo restores a recorded earlier Pod template. Here the stated fault follows a different mechanism: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state. The corrective choice is “Run kubectl -n observability scale deployment/metrics-api --replicas=4”.

C:

The offered action targets: Requests inform scheduling and limits cap runtime consumption; the settings play different roles. The case facts point instead to: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state. Implement “Run kubectl -n observability scale deployment/metrics-api --replicas=4” to address that specific condition.

D:

This alternative is a response to another technical cause: A successful API mutation does not guarantee updated Pods are healthy and available; rollout status tracks controller progress. The reported case instead depends on: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state. The action that directly addresses it is “Run kubectl -n observability scale deployment/metrics-api --replicas=4”.

Question 306

At Horizon observability, in a disposable simulated environment during a monitored release window: The Deployment metrics-api in namespace observability must run exactly 4 replicas during a planned demand change. Work only within the stated target and verify before declaring success. Which Kubernetes behavior best explains the required change or diagnosis?

  1. HPA evaluates metrics relative to Pod resource requests; missing metrics or requests can leave desired replicas unknown.
  2. Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state.
  3. Rollout restart annotates the Pod template so the Deployment controller replaces Pods according to its rollout strategy.
  4. Deployment rolling-update parameters govern how many old Pods may be unavailable and extra Pods may be created during replacement.

Explanation

Correct Answer

B:

Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state. This explains the stated condition. The corresponding action is: Run kubectl -n observability scale deployment/metrics-api --replicas=4. The direct acceptance evidence is: Run kubectl -n observability rollout status deployment/metrics-api and kubectl -n observability get deployment metrics-api to compare desired and ready counts.

Incorrect Answers

A:

HPA evaluates metrics relative to Pod resource requests; missing metrics or requests can leave desired replicas unknown. That explanation applies to a different technical failure. Here the controlling principle is: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state.

C:

This principle describes a separate cause: Rollout restart annotates the Pod template so the Deployment controller replaces Pods according to its rollout strategy. The reported condition is governed by: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state. The two mechanisms should not be conflated.

D:

Deployment rolling-update parameters govern how many old Pods may be unavailable and extra Pods may be created during replacement. That explanation applies to a different technical failure. Here the controlling principle is: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state.

Question 307

At Horizon observability, in a disposable simulated environment during a monitored release window: The Deployment metrics-api in namespace observability must run exactly 4 replicas during a planned demand change. Work only within the stated target and verify before declaring success. Which observation best verifies the requested outcome rather than an unrelated state?

  1. Run kubectl -n observability describe deployment metrics-api and inspect the environment references on newly created Pods.
  2. Run kubectl -n observability rollout status deployment/metrics-api and inspect new Pod creation timestamps.
  3. Run kubectl -n observability rollout status deployment/metrics-api and kubectl -n observability get deployment metrics-api to compare desired and ready counts.
  4. Run kubectl -n fulfillment rollout status deployment/dispatch-api and inspect the restored image and configuration.

Explanation

Correct Answer

C:

Run kubectl -n observability rollout status deployment/metrics-api and kubectl -n observability get deployment metrics-api to compare desired and ready counts. This validates the affected object or control path, rather than only showing a command completed. The underlying reason is: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state. The intended action is: Run kubectl -n observability scale deployment/metrics-api --replicas=4.

Incorrect Answers

A:

That test belongs to another control with this basis: Environment variables are copied into new container processes from ConfigMap values; existing running processes need replacement to pick up changes. In the current case, the governing reason is: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state. The direct verification is “Run kubectl -n observability rollout status deployment/metrics-api and kubectl -n observability get deployment metrics-api to compare desired and ready counts”.

B:

This observation would test a different technical dependency: Rollout restart annotates the Pod template so the Deployment controller replaces Pods according to its rollout strategy. The current issue is governed by: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state. Its decisive check is “Run kubectl -n observability rollout status deployment/metrics-api and kubectl -n observability get deployment metrics-api to compare desired and ready counts”.

D:

That test belongs to another control with this basis: A Deployment tracks ReplicaSet revisions and rollout undo restores a recorded earlier Pod template. In the current case, the governing reason is: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state. The direct verification is “Run kubectl -n observability rollout status deployment/metrics-api and kubectl -n observability get deployment metrics-api to compare desired and ready counts”.

Question 308

At Horizon observability, in a disposable simulated environment during a monitored release window: The Deployment metrics-api in namespace observability must run exactly 4 replicas during a planned demand change. Work only within the stated target and verify before declaring success. Which operational control most directly prevents this failure or configuration drift?

  1. Pin reviewed image tags or digests and retain rollout history for recovery.
  2. Retain meaningful revisions and perform health checks after every rollback.
  3. Keep secret values out of logs and plan rollouts when Secret-backed environment variables change.
  4. Use reviewed scaling boundaries and monitor HPA ownership before manual replica changes.

Explanation

Correct Answer

D:

Use reviewed scaling boundaries and monitor HPA ownership before manual replica changes. This reduces recurrence of the specific operational failure. It reinforces the action: Run kubectl -n observability scale deployment/metrics-api --replicas=4. The relevant mechanism is: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state.

Incorrect Answers

A:

This routine guards against another mechanism: Updating a Deployment Pod template triggers a controlled rollout; restarting Pods alone will not change the image reference. The recurring exposure in the current case is: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state. The matching preventive check is “Use reviewed scaling boundaries and monitor HPA ownership before manual replica changes”.

B:

The suggested review tracks a different technical risk: A Deployment tracks ReplicaSet revisions and rollout undo restores a recorded earlier Pod template. Here the sustained control must address: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state. Choose “Use reviewed scaling boundaries and monitor HPA ownership before manual replica changes”.

C:

That safeguard is relevant to: Pod templates can reference Secret keys without copying literal secret values into the Deployment spec. The current failure instead follows from: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state. Its prevention measure is “Use reviewed scaling boundaries and monitor HPA ownership before manual replica changes”.

Question 309

At Pinecrest logistics, in a sandbox Kubernetes cluster during a recovery tabletop exercise: The Deployment dispatch-api in namespace fulfillment must run exactly 5 replicas during a planned demand change. Work only within the stated target and verify before declaring success. Which command or initial safe diagnostic step best addresses the stated lab task?

  1. Run kubectl -n fulfillment create secret generic lab-dispatch-key --from-literal=TOKEN=dummy-demo-three for this disposable lab only.
  2. Run kubectl -n fulfillment scale deployment/dispatch-api --replicas=5.
  3. Run kubectl -n fulfillment set env deployment/dispatch-api --from=configmap/dispatch-config.
  4. Run kubectl -n fulfillment patch cronjob nightly-sync --type=merge -p '{"spec":{"suspend":true}}'.

Explanation

Correct Answer

B:

Run kubectl -n fulfillment scale deployment/dispatch-api --replicas=5. This is the appropriate command-line action or first safe diagnostic. The technical reason is: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state. Validate the result with: Run kubectl -n fulfillment rollout status deployment/dispatch-api and kubectl -n fulfillment get deployment dispatch-api to compare desired and ready counts. Execute changes only in an authorized disposable lab or after normal production change controls.

Incorrect Answers

A:

The proposed action belongs to the mechanism: Kubernetes Secrets are API objects intended for sensitive values, but literals in a shell command can leak via shell history and process observation. Here the stated fault follows a different mechanism: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state. The corrective choice is “Run kubectl -n fulfillment scale deployment/dispatch-api --replicas=5”.

C:

This alternative is a response to another technical cause: Environment variables are copied into new container processes from ConfigMap values; existing running processes need replacement to pick up changes. The reported case instead depends on: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state. The action that directly addresses it is “Run kubectl -n fulfillment scale deployment/dispatch-api --replicas=5”.

D:

The proposed action belongs to the mechanism: CronJob suspension prevents new scheduled Jobs but does not terminate existing Jobs already running. Here the stated fault follows a different mechanism: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state. The corrective choice is “Run kubectl -n fulfillment scale deployment/dispatch-api --replicas=5”.

Question 310

At Pinecrest logistics, in a sandbox Kubernetes cluster during a recovery tabletop exercise: The Deployment dispatch-api in namespace fulfillment must run exactly 5 replicas during a planned demand change. Work only within the stated target and verify before declaring success. Which Kubernetes behavior best explains the required change or diagnosis?

  1. Pod templates can reference Secret keys without copying literal secret values into the Deployment spec.
  2. Requests inform scheduling and limits cap runtime consumption; the settings play different roles.
  3. Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state.
  4. A Deployment tracks ReplicaSet revisions and rollout undo restores a recorded earlier Pod template.

Explanation

Correct Answer

C:

Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state. This explains the stated condition. The corresponding action is: Run kubectl -n fulfillment scale deployment/dispatch-api --replicas=5. The direct acceptance evidence is: Run kubectl -n fulfillment rollout status deployment/dispatch-api and kubectl -n fulfillment get deployment dispatch-api to compare desired and ready counts.

Incorrect Answers

A:

The offered statement is true for this other mechanism: Pod templates can reference Secret keys without copying literal secret values into the Deployment spec. It does not explain the facts described here, which follow from: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state.

B:

This principle describes a separate cause: Requests inform scheduling and limits cap runtime consumption; the settings play different roles. The reported condition is governed by: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state. The two mechanisms should not be conflated.

D:

The offered statement is true for this other mechanism: A Deployment tracks ReplicaSet revisions and rollout undo restores a recorded earlier Pod template. It does not explain the facts described here, which follow from: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state.