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 41

Question 400

At Northstar finance, in an isolated training cluster during a scheduled maintenance rehearsal: Deployment invoice-api in ledger needs each named container's CPU request set to 250m and memory limit set to 256Mi. Work only within the stated target and verify before declaring success. Which operational control most directly prevents this failure or configuration drift?

  1. Check disruption budgets and readiness behavior before application restarts.
  2. Control privileged node labels and review availability before adding hard scheduling constraints.
  3. Review resource sizing against actual usage and avoid scheduling on unsupported limits alone.
  4. Gate deployment promotion on observed rollout and readiness rather than API command exit alone.

Explanation

Correct Answer

C:

Review resource sizing against actual usage and avoid scheduling on unsupported limits alone. This reduces recurrence of the specific operational failure. It reinforces the action: Run kubectl -n ledger set resources deployment/invoice-api --requests=cpu=250m --limits=memory=256Mi after verifying the Deployment's container selection. The relevant mechanism is: Requests inform scheduling and limits cap runtime consumption; the settings play different roles.

Incorrect Answers

A:

That safeguard is relevant to: Rollout restart annotates the Pod template so the Deployment controller replaces Pods according to its rollout strategy. The current failure instead follows from: Requests inform scheduling and limits cap runtime consumption; the settings play different roles. Its prevention measure is “Review resource sizing against actual usage and avoid scheduling on unsupported limits alone”.

B:

This routine guards against another mechanism: Node selectors constrain scheduling to nodes whose labels match all specified key/value pairs; patching the Pod template triggers a rollout. The recurring exposure in the current case is: Requests inform scheduling and limits cap runtime consumption; the settings play different roles. The matching preventive check is “Review resource sizing against actual usage and avoid scheduling on unsupported limits alone”.

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: Requests inform scheduling and limits cap runtime consumption; the settings play different roles. Its prevention measure is “Review resource sizing against actual usage and avoid scheduling on unsupported limits alone”.

Question 401

At Horizon observability, in a disposable simulated environment during a monitored release window: Deployment metrics-api in observability needs each named container's CPU request set to 400m and memory limit set to 384Mi. 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 set resources deployment/metrics-api --requests=cpu=400m --limits=memory=384Mi after verifying the Deployment's container selection.
  2. Run kubectl -n observability patch deployment metrics-api --type=merge -p '{"spec":{"template":{"spec":{"tolerations":[{"key":"special","operator":"Equal","value":"dedicated","effect":"NoSchedule"}]}}}}' after checking existing tolerations.
  3. Run kubectl -n observability autoscale deployment metrics-api --cpu-percent=70 --min=3 --max=8 after setting valid CPU requests.
  4. Run kubectl -n observability rollout restart deployment/metrics-api.

Explanation

Correct Answer

A:

Run kubectl -n observability set resources deployment/metrics-api --requests=cpu=400m --limits=memory=384Mi after verifying the Deployment's container selection. This is the appropriate command-line action or first safe diagnostic. The technical reason is: Requests inform scheduling and limits cap runtime consumption; the settings play different roles. Validate the result with: Run kubectl -n observability get deployment metrics-api -o yaml and inspect resource requests and limits for each container. 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 toleration allows a Pod past a matching taint but does not ensure placement without node selection and capacity. Here the stated fault follows a different mechanism: Requests inform scheduling and limits cap runtime consumption; the settings play different roles. The corrective choice is “Run kubectl -n observability set resources deployment/metrics-api --requests=cpu=400m --limits=memory=384Mi after verifying the Deployment's container selection”.

C:

The offered action targets: HPA evaluates metrics relative to Pod resource requests; missing metrics or requests can leave desired replicas unknown. The case facts point instead to: Requests inform scheduling and limits cap runtime consumption; the settings play different roles. Implement “Run kubectl -n observability set resources deployment/metrics-api --requests=cpu=400m --limits=memory=384Mi after verifying the Deployment's container selection” to address that specific condition.

D:

This alternative is a response to another technical cause: Rollout restart annotates the Pod template so the Deployment controller replaces Pods according to its rollout strategy. The reported case instead depends on: Requests inform scheduling and limits cap runtime consumption; the settings play different roles. The action that directly addresses it is “Run kubectl -n observability set resources deployment/metrics-api --requests=cpu=400m --limits=memory=384Mi after verifying the Deployment's container selection”.

Question 402

At Horizon observability, in a disposable simulated environment during a monitored release window: Deployment metrics-api in observability needs each named container's CPU request set to 400m and memory limit set to 384Mi. Work only within the stated target and verify before declaring success. Which Kubernetes behavior best explains the required change or diagnosis?

  1. A toleration allows a Pod past a matching taint but does not ensure placement without node selection and capacity.
  2. Requests inform scheduling and limits cap runtime consumption; the settings play different roles.
  3. Updating a Deployment Pod template triggers a controlled rollout; restarting Pods alone will not change the image reference.
  4. Environment variables are copied into new container processes from ConfigMap values; existing running processes need replacement to pick up changes.

Explanation

Correct Answer

B:

Requests inform scheduling and limits cap runtime consumption; the settings play different roles. This explains the stated condition. The corresponding action is: Run kubectl -n observability set resources deployment/metrics-api --requests=cpu=400m --limits=memory=384Mi after verifying the Deployment's container selection. The direct acceptance evidence is: Run kubectl -n observability get deployment metrics-api -o yaml and inspect resource requests and limits for each container.

Incorrect Answers

A:

A toleration allows a Pod past a matching taint but does not ensure placement without node selection and capacity. That explanation applies to a different technical failure. Here the controlling principle is: Requests inform scheduling and limits cap runtime consumption; the settings play different roles.

C:

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: Requests inform scheduling and limits cap runtime consumption; the settings play different roles. The two mechanisms should not be conflated.

D:

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: Requests inform scheduling and limits cap runtime consumption; the settings play different roles.

Question 403

At Horizon observability, in a disposable simulated environment during a monitored release window: Deployment metrics-api in observability needs each named container's CPU request set to 400m and memory limit set to 384Mi. 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 rollout status deployment/metrics-api and inspect the restored image and configuration.
  2. Run kubectl -n observability rollout status deployment/metrics-api and inspect new Pod creation timestamps.
  3. Run kubectl -n observability get deployment metrics-api -o yaml and inspect resource requests and limits for each container.
  4. Run kubectl -n fulfillment describe deployment dispatch-api and inspect the environment references on newly created Pods.

Explanation

Correct Answer

C:

Run kubectl -n observability get deployment metrics-api -o yaml and inspect resource requests and limits for each container. This validates the affected object or control path, rather than only showing a command completed. The underlying reason is: Requests inform scheduling and limits cap runtime consumption; the settings play different roles. The intended action is: Run kubectl -n observability set resources deployment/metrics-api --requests=cpu=400m --limits=memory=384Mi after verifying the Deployment's container selection.

Incorrect Answers

A:

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: Requests inform scheduling and limits cap runtime consumption; the settings play different roles. The direct verification is “Run kubectl -n observability get deployment metrics-api -o yaml and inspect resource requests and limits for each container”.

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: Requests inform scheduling and limits cap runtime consumption; the settings play different roles. Its decisive check is “Run kubectl -n observability get deployment metrics-api -o yaml and inspect resource requests and limits for each container”.

D:

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: Requests inform scheduling and limits cap runtime consumption; the settings play different roles. The direct verification is “Run kubectl -n observability get deployment metrics-api -o yaml and inspect resource requests and limits for each container”.

Question 404

At Horizon observability, in a disposable simulated environment during a monitored release window: Deployment metrics-api in observability needs each named container's CPU request set to 400m and memory limit set to 384Mi. Work only within the stated target and verify before declaring success. Which operational control most directly prevents this failure or configuration drift?

  1. Track HPA metric availability and avoid simultaneous manual scaling policies that fight the controller.
  2. Keep secret values out of logs and plan rollouts when Secret-backed environment variables change.
  3. Assess capacity for surge Pods and measure availability during upgrades.
  4. Review resource sizing against actual usage and avoid scheduling on unsupported limits alone.

Explanation

Correct Answer

D:

Review resource sizing against actual usage and avoid scheduling on unsupported limits alone. This reduces recurrence of the specific operational failure. It reinforces the action: Run kubectl -n observability set resources deployment/metrics-api --requests=cpu=400m --limits=memory=384Mi after verifying the Deployment's container selection. The relevant mechanism is: Requests inform scheduling and limits cap runtime consumption; the settings play different roles.

Incorrect Answers

A:

This routine guards against another mechanism: HPA evaluates metrics relative to Pod resource requests; missing metrics or requests can leave desired replicas unknown. The recurring exposure in the current case is: Requests inform scheduling and limits cap runtime consumption; the settings play different roles. The matching preventive check is “Review resource sizing against actual usage and avoid scheduling on unsupported limits alone”.

B:

The suggested review tracks a different technical risk: Pod templates can reference Secret keys without copying literal secret values into the Deployment spec. Here the sustained control must address: Requests inform scheduling and limits cap runtime consumption; the settings play different roles. Choose “Review resource sizing against actual usage and avoid scheduling on unsupported limits alone”.

C:

That safeguard is relevant to: Deployment rolling-update parameters govern how many old Pods may be unavailable and extra Pods may be created during replacement. The current failure instead follows from: Requests inform scheduling and limits cap runtime consumption; the settings play different roles. Its prevention measure is “Review resource sizing against actual usage and avoid scheduling on unsupported limits alone”.

Question 405

At Pinecrest logistics, in a sandbox Kubernetes cluster during a recovery tabletop exercise: Deployment dispatch-api in fulfillment needs each named container's CPU request set to 600m and memory limit set to 512Mi. 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 patch deployment dispatch-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 set resources deployment/dispatch-api --requests=cpu=600m --limits=memory=512Mi after verifying the Deployment's container selection.
  3. Run kubectl -n fulfillment autoscale deployment dispatch-api --cpu-percent=75 --min=2 --max=9 after setting valid CPU requests.
  4. Run kubectl -n observability autoscale deployment metrics-api --cpu-percent=70 --min=3 --max=8 after setting valid CPU requests.

Explanation

Correct Answer

B:

Run kubectl -n fulfillment set resources deployment/dispatch-api --requests=cpu=600m --limits=memory=512Mi after verifying the Deployment's container selection. This is the appropriate command-line action or first safe diagnostic. The technical reason is: Requests inform scheduling and limits cap runtime consumption; the settings play different roles. Validate the result with: Run kubectl -n fulfillment get deployment dispatch-api -o yaml and inspect resource requests and limits for each container. Execute changes only in an authorized disposable lab or after normal production change controls.

Incorrect Answers

A:

The proposed action belongs to the mechanism: A toleration allows a Pod past a matching taint but does not ensure placement without node selection and capacity. Here the stated fault follows a different mechanism: Requests inform scheduling and limits cap runtime consumption; the settings play different roles. The corrective choice is “Run kubectl -n fulfillment set resources deployment/dispatch-api --requests=cpu=600m --limits=memory=512Mi after verifying the Deployment's container selection”.

C:

This alternative is a response to another technical cause: HPA evaluates metrics relative to Pod resource requests; missing metrics or requests can leave desired replicas unknown. The reported case instead depends on: Requests inform scheduling and limits cap runtime consumption; the settings play different roles. The action that directly addresses it is “Run kubectl -n fulfillment set resources deployment/dispatch-api --requests=cpu=600m --limits=memory=512Mi after verifying the Deployment's container selection”.

D:

The proposed action belongs to the mechanism: HPA evaluates metrics relative to Pod resource requests; missing metrics or requests can leave desired replicas unknown. Here the stated fault follows a different mechanism: Requests inform scheduling and limits cap runtime consumption; the settings play different roles. The corrective choice is “Run kubectl -n fulfillment set resources deployment/dispatch-api --requests=cpu=600m --limits=memory=512Mi after verifying the Deployment's container selection”.

Question 406

At Pinecrest logistics, in a sandbox Kubernetes cluster during a recovery tabletop exercise: Deployment dispatch-api in fulfillment needs each named container's CPU request set to 600m and memory limit set to 512Mi. Work only within the stated target and verify before declaring success. Which Kubernetes behavior best explains the required change or diagnosis?

  1. Rollout restart annotates the Pod template so the Deployment controller replaces Pods according to its rollout strategy.
  2. Updating a Deployment Pod template triggers a controlled rollout; restarting Pods alone will not change the image reference.
  3. Requests inform scheduling and limits cap runtime consumption; the settings play different roles.
  4. A toleration allows a Pod past a matching taint but does not ensure placement without node selection and capacity.

Explanation

Correct Answer

C:

Requests inform scheduling and limits cap runtime consumption; the settings play different roles. This explains the stated condition. The corresponding action is: Run kubectl -n fulfillment set resources deployment/dispatch-api --requests=cpu=600m --limits=memory=512Mi after verifying the Deployment's container selection. The direct acceptance evidence is: Run kubectl -n fulfillment get deployment dispatch-api -o yaml and inspect resource requests and limits for each container.

Incorrect Answers

A:

The offered statement is true for this other mechanism: Rollout restart annotates the Pod template so the Deployment controller replaces Pods according to its rollout strategy. It does not explain the facts described here, which follow from: Requests inform scheduling and limits cap runtime consumption; the settings play different roles.

B:

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: Requests inform scheduling and limits cap runtime consumption; the settings play different roles. The two mechanisms should not be conflated.

D:

The offered statement is true for this other mechanism: A toleration allows a Pod past a matching taint but does not ensure placement without node selection and capacity. It does not explain the facts described here, which follow from: Requests inform scheduling and limits cap runtime consumption; the settings play different roles.

Question 407

At Pinecrest logistics, in a sandbox Kubernetes cluster during a recovery tabletop exercise: Deployment dispatch-api in fulfillment needs each named container's CPU request set to 600m and memory limit set to 512Mi. 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 fulfillment describe deployment dispatch-api and inspect environment key references without printing secret values.
  2. Run kubectl -n fulfillment get configmap dispatch-config -o jsonpath='{.data.MODE}' and confirm the declared value.
  3. Run kubectl -n fulfillment get hpa dispatch-api and inspect observed utilization and replica bounds.
  4. Run kubectl -n fulfillment get deployment dispatch-api -o yaml and inspect resource requests and limits for each container.

Explanation

Correct Answer

D:

Run kubectl -n fulfillment get deployment dispatch-api -o yaml and inspect resource requests and limits for each container. This validates the affected object or control path, rather than only showing a command completed. The underlying reason is: Requests inform scheduling and limits cap runtime consumption; the settings play different roles. The intended action is: Run kubectl -n fulfillment set resources deployment/dispatch-api --requests=cpu=600m --limits=memory=512Mi after verifying the Deployment's container selection.

Incorrect Answers

A:

This observation would test a different technical dependency: Pod templates can reference Secret keys without copying literal secret values into the Deployment spec. The current issue is governed by: Requests inform scheduling and limits cap runtime consumption; the settings play different roles. Its decisive check is “Run kubectl -n fulfillment get deployment dispatch-api -o yaml and inspect resource requests and limits for each container”.

B:

The alternative verifies a different condition: ConfigMaps hold ordinary configuration data; their existence does not automatically inject values into running Pods. The current case instead depends on: Requests inform scheduling and limits cap runtime consumption; the settings play different roles. Confirm that “Run kubectl -n fulfillment get deployment dispatch-api -o yaml and inspect resource requests and limits for each container”.

C:

That test belongs to another control with this basis: HPA evaluates metrics relative to Pod resource requests; missing metrics or requests can leave desired replicas unknown. In the current case, the governing reason is: Requests inform scheduling and limits cap runtime consumption; the settings play different roles. The direct verification is “Run kubectl -n fulfillment get deployment dispatch-api -o yaml and inspect resource requests and limits for each container”.

Question 408

At Pinecrest logistics, in a sandbox Kubernetes cluster during a recovery tabletop exercise: Deployment dispatch-api in fulfillment needs each named container's CPU request set to 600m and memory limit set to 512Mi. Work only within the stated target and verify before declaring success. Which operational control most directly prevents this failure or configuration drift?

  1. Review resource sizing against actual usage and avoid scheduling on unsupported limits alone.
  2. Track HPA metric availability and avoid simultaneous manual scaling policies that fight the controller.
  3. Track whether consumers use environment variables or mounted files when planning ConfigMap refreshes.
  4. Gate deployment promotion on observed rollout and readiness rather than API command exit alone.

Explanation

Correct Answer

A:

Review resource sizing against actual usage and avoid scheduling on unsupported limits alone. This reduces recurrence of the specific operational failure. It reinforces the action: Run kubectl -n fulfillment set resources deployment/dispatch-api --requests=cpu=600m --limits=memory=512Mi after verifying the Deployment's container selection. The relevant mechanism is: Requests inform scheduling and limits cap runtime consumption; the settings play different roles.

Incorrect Answers

B:

That safeguard is relevant to: HPA evaluates metrics relative to Pod resource requests; missing metrics or requests can leave desired replicas unknown. The current failure instead follows from: Requests inform scheduling and limits cap runtime consumption; the settings play different roles. Its prevention measure is “Review resource sizing against actual usage and avoid scheduling on unsupported limits alone”.

C:

This routine guards against another mechanism: Environment variables are copied into new container processes from ConfigMap values; existing running processes need replacement to pick up changes. The recurring exposure in the current case is: Requests inform scheduling and limits cap runtime consumption; the settings play different roles. The matching preventive check is “Review resource sizing against actual usage and avoid scheduling on unsupported limits alone”.

D:

The suggested review tracks a different technical risk: A successful API mutation does not guarantee updated Pods are healthy and available; rollout status tracks controller progress. Here the sustained control must address: Requests inform scheduling and limits cap runtime consumption; the settings play different roles. Choose “Review resource sizing against actual usage and avoid scheduling on unsupported limits alone”.

Question 409

At Northstar finance, in an isolated training cluster during a scheduled maintenance rehearsal: The Deployment invoice-api in namespace ledger must target nodes labeled workload=restricted in a disposable lab. 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 patch deployment dispatch-api --type=merge -p '{"spec":{"template":{"spec":{"tolerations":[{"key":"special","operator":"Equal","value":"dedicated","effect":"NoSchedule"}]}}}}' after checking existing tolerations.
  2. Run kubectl -n ledger rollout undo deployment/invoice-api after checking rollout history.
  3. Run kubectl -n ledger patch deployment invoice-api --type=merge -p '{"spec":{"template":{"spec":{"nodeSelector":{"workload":"restricted"}}}}}'.
  4. Run kubectl -n ledger patch cronjob daily-archive --type=merge -p '{"spec":{"suspend":true}}'.

Explanation

Correct Answer

C:

Run kubectl -n ledger patch deployment invoice-api --type=merge -p '{"spec":{"template":{"spec":{"nodeSelector":{"workload":"restricted"}}}}}'. This is the appropriate command-line action or first safe diagnostic. The technical reason is: Node selectors constrain scheduling to nodes whose labels match all specified key/value pairs; patching the Pod template triggers a rollout. Validate the result with: Run kubectl -n ledger get deployment invoice-api -o jsonpath='{.spec.template.spec.nodeSelector}' and check Pod placements. 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: Node selectors constrain scheduling to nodes whose labels match all specified key/value pairs; patching the Pod template triggers a rollout. Implement “Run kubectl -n ledger patch deployment invoice-api --type=merge -p '{"spec":{"template":{"spec":{"nodeSelector":{"workload":"restricted"}}}}}'” 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: Node selectors constrain scheduling to nodes whose labels match all specified key/value pairs; patching the Pod template triggers a rollout. The action that directly addresses it is “Run kubectl -n ledger patch deployment invoice-api --type=merge -p '{"spec":{"template":{"spec":{"nodeSelector":{"workload":"restricted"}}}}}'”.

D:

The offered action targets: CronJob suspension prevents new scheduled Jobs but does not terminate existing Jobs already running. The case facts point instead to: Node selectors constrain scheduling to nodes whose labels match all specified key/value pairs; patching the Pod template triggers a rollout. Implement “Run kubectl -n ledger patch deployment invoice-api --type=merge -p '{"spec":{"template":{"spec":{"nodeSelector":{"workload":"restricted"}}}}}'” to address that specific condition.

Question 410

At Northstar finance, in an isolated training cluster during a scheduled maintenance rehearsal: The Deployment invoice-api in namespace ledger must target nodes labeled workload=restricted in a disposable lab. 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. Deployment rolling-update parameters govern how many old Pods may be unavailable and extra Pods may be created during replacement.
  3. A toleration allows a Pod past a matching taint but does not ensure placement without node selection and capacity.
  4. Node selectors constrain scheduling to nodes whose labels match all specified key/value pairs; patching the Pod template triggers a rollout.

Explanation

Correct Answer

D:

Node selectors constrain scheduling to nodes whose labels match all specified key/value pairs; patching the Pod template triggers a rollout. This explains the stated condition. The corresponding action is: Run kubectl -n ledger patch deployment invoice-api --type=merge -p '{"spec":{"template":{"spec":{"nodeSelector":{"workload":"restricted"}}}}}'. The direct acceptance evidence is: Run kubectl -n ledger get deployment invoice-api -o jsonpath='{.spec.template.spec.nodeSelector}' and check Pod placements.

Incorrect Answers

A:

This principle describes a separate cause: Scaling the Deployment changes desired replica count through its controller; editing an individual Pod would not preserve the desired state. The reported condition is governed by: Node selectors constrain scheduling to nodes whose labels match all specified key/value pairs; patching the Pod template triggers a rollout. The two mechanisms should not be conflated.

B:

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: Node selectors constrain scheduling to nodes whose labels match all specified key/value pairs; patching the Pod template triggers a rollout.

C:

The offered statement is true for this other mechanism: A toleration allows a Pod past a matching taint but does not ensure placement without node selection and capacity. It does not explain the facts described here, which follow from: Node selectors constrain scheduling to nodes whose labels match all specified key/value pairs; patching the Pod template triggers a rollout.