KCNA study plan

Create, inspect, and delete Pods and Namespaces using both imperative kubectl commands and a declarative YAML manifest you wrote by hand

Label and select subsets of Pods with kubectl label and -l selectors, then predict and verify the result of each selector query

Navigate live cluster state using kubectl get, describe, logs, exec, and get events to answer where an object lives and why it is in its current state

Map each core object (Pod, ReplicaSet, Deployment, Service, ConfigMap, Secret, Namespace) to the specific problem it solves and state one thing it does not do

Deploy a multi-replica application with a Deployment and expose it through ClusterIP and NodePort Services, then trace which Endpoints back each Service

Resolve in-cluster service discovery by name from a test Pod and explain the resulting DNS name and search-domain behavior

Inject configuration with ConfigMaps and Secrets as both environment variables and mounted volumes, then observe what happens when a key is missing

Perform a rolling update and a rollback, capturing revision history with kubectl rollout status and rollout history

Provision persistent storage by binding a PersistentVolume to a PersistentVolumeClaim and mounting it into a Pod, then prove data survives Pod deletion

Set CPU and memory requests and limits, then diagnose what happens to a Pod that exceeds each one

Apply scheduling constraints (nodeSelector, affinity, taints/tolerations) and confirm placement with kubectl get pods -o wide

Diagnose CrashLoopBackOff, ImagePullBackOff, and Pending states from events and container logs without guessing

Build a container image with a multi-stage Dockerfile and explain what each layer contributes to image size and cache reuse

Trace a container's lifecycle from image pull through start, readiness, liveness, and termination, and describe which probe gates which transition

Configure liveness, readiness, and startup probes and document the observed cluster behavior when each one fails

Classify Pods into QoS classes by their resource settings and predict eviction order under node pressure

Demonstrate self-healing by deleting a Pod and draining a node, recording how the ReplicaSet and scheduler restore the desired state

Scale a workload horizontally and explain when to choose manual scaling versus a HorizontalPodAutoscaler with a metrics source

Implement the sidecar and init-container patterns and justify each against a single-container alternative

Roll out a deliberately broken image, then recover using rollback and revision pinning while keeping the Service available

Package the week-2 application as a parameterized Helm chart with values-driven environment differences and lint it before install

Design a delivery pipeline that builds, scans, signs, deploys, and verifies an immutable image tag, naming the failure gate at each stage

Compare canary and blue-green release strategies and state which metric would trigger an automatic rollback in each

Describe how a GitOps controller reconciles desired versus live state and what it does on drift

Compare monolithic and microservice decompositions for a given workload and defend one choice with at least three concrete tradeoffs

Specify the metrics, logs, and traces you would collect for the three-tier app and identify the signal that answers a stated failure question

Apply least-privilege RBAC and a default-deny NetworkPolicy, then verify from inside the cluster that the intended traffic is blocked

Explain where a service mesh adds value over native Kubernetes networking and where it adds unacceptable operational cost

Re-drill every item missed in prior weeks until each one is answered correctly twice in a row without notes

Complete two timed mixed-domain practice runs under exam pacing and review every incorrect item down to the underlying concept

Teach back the five weakest concepts aloud or in writing to expose gaps that recognition-only study hides

Rebalance remaining study time toward domain 1 and domain 2 items still scoring below target