EXAMTOPICS / TECHNOLOGY INSIGHTS

CNCF CKAD: Hands-On Kubernetes Application Deployment and Troubleshooting

Exam scope and the right preparation method

The Certified Kubernetes Application Developer (CKAD) is a CNCF performance-based examination administered online in a command-line environment. It allows approximately two hours for practical tasks. The published domains are Application Design and Build (20%), Application Deployment (20%), Application Observability and Maintenance (15%), Application Environment, Configuration and Security (25%), and Services and Networking (20%). These are domain weights, not a promise that every objective will appear as a separate task.

Preparation should therefore resemble working on an isolated practice cluster: read the requirement, choose the smallest correct Kubernetes resource, apply a manifest, verify observed behavior and diagnose errors. Memorizing definitions without producing or troubleshooting real objects is a weak match for a performance-based test. The Linux Foundation candidate information is the relevant source for current exam logistics and credential validity.

Deployment, labels and readiness

A Deployment describes a desired set of Pods and the rollout of application versions. Its selector must match the Pod template labels. In a practice cluster, start with a simple API service, a fixed container image tag and a readiness probe. The following is an illustrative manifest, not a claim about a specific production application:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: sample-api
spec:
  replicas: 2
  selector:
    matchLabels:
      app: sample-api
  template:
    metadata:
      labels:
        app: sample-api
    spec:
      containers:
      - name: api
        image: example.invalid/sample-api:1.0
        ports:
        - containerPort: 8080
        readinessProbe:
          httpGet:
            path: /ready
            port: 8080
          periodSeconds: 5

The placeholder image will not run unless replaced with an accessible test image that actually serves /ready. That limitation is intentional: it makes the difference between a syntactically correct resource and an operational workload visible. Inspect the object with kubectl describe deployment sample-api, use kubectl rollout status deployment/sample-api, then examine Pod events, container logs and probe failures.

A deployment can report the desired replica count while the application remains unavailable. Compare desired, current, ready and available replicas, then inspect pod events and container logs. An image-pull error, missing ConfigMap key and failing readiness probe lead to different fixes. Change only one cause at a time and verify the result with both a readiness condition and a request through the intended Service. Merely observing that a pod is in a Running phase is not proof of application availability.

Labels and selectors are part of the network path. A Service with a selector that does not match the deployment pods may exist and receive a cluster IP while returning no endpoints. In a small isolated namespace, deploy two differently labelled workloads, inspect endpoint discovery and explain why one is selected. This makes a common CKAD troubleshooting question observable without relying on memorized command output.

Configuration, security and rollout choices

Applications should consume environment-specific settings through ConfigMaps or Secrets, not hard-coded credentials inside public manifests. Practice mounting configuration and using a ServiceAccount scoped to the task. A learner should know how a container security context, resource limits and a NetworkPolicy change runtime behavior, and how to determine whether a denial is caused by RBAC, network controls or the application itself.

For a rolling update, change a container image and observe rollout status before relying on a success message. If readiness never becomes healthy, check the image pull, process port, Service selectors and readiness endpoint. Distinguish the deployment controller from the Service: the controller manages Pods; the Service provides stable selection and access to eligible endpoints.

Configuration and secret delivery deserve separate practice. A ConfigMap can hold a nonsensitive endpoint name; a Secret can provide a credential to a permitted workload, but storing it in a Kubernetes Secret does not automatically establish comprehensive encryption or least-privilege access. Verify the ServiceAccount, namespace, resource requests and mount or environment mapping used by the application. Avoid printing real secret values into a terminal history, CI log or portfolio screenshot.

For a rollout exercise, deploy a known working image, introduce a deliberately failing readiness probe, inspect rollout status and restore the last stable state using the supported mechanism. Record both the rollback command and the observable result. Explain the difference between a deployment strategy and a readiness check: a rolling update can progress only when the application satisfies the criteria defined by the deployment.

Services, ingress and observability

Practice creating a ClusterIP Service with a selector matching the running Pods. Compare a successful in-cluster request with a failed request caused by a label mismatch or target-port error. If using Ingress, confirm that an ingress controller exists; an Ingress resource alone does not necessarily provision a working data path. Inspect EndpointSlices, DNS resolution and application logs rather than guessing at connectivity problems.

The CKAD curriculum covers probes, logs, monitoring and debugging, alongside common deployment strategies and application configuration. A useful practice case includes a deliberate failure: wrong port, missing ConfigMap, invalid image, insufficient resource quota or denied service account permission. State the symptom, collect evidence, correct the smallest setting and verify recovery.

Practice exposing a service inside a namespace before attempting an Ingress or external route. Verify the selected pods, container port, Service targetPort and protocol, then decide whether a cluster-internal, node-level or ingress-mediated path fits the use case. When traffic fails, inspect endpoints, application readiness and DNS resolution rather than immediately changing network policy. Treat ingress controller installation as a cluster-administrator prerequisite if the provided environment does not already include one.

A repeatable preparation routine

Run timed exercises that cover building images, selecting Deployments versus Jobs or CronJobs, configuring multi-container Pods, applying resources, verifying rollouts and diagnosing faulty Services. After each session, record the commands you used and whether they demonstrated the desired state. Check the official exam environment version because Kubernetes minor versions and deprecated APIs change.

A supporting DevOps delivery workflow discussion is relevant when exploring how tested application manifests reach a cluster through CI/CD; it is not a substitute for CKAD command-line practice. Use current CNCF objectives and documented cluster behavior as the final authority.

CNCF lists five CKAD domains weighted 20%, 20%, 15%, 25% and 20%. A study log can track command fluency and error diagnosis against these domains without treating weight percentages as a promise of which tasks will appear in a particular sitting. Rehearse namespace-safe commands, inspect the objects that the exam environment supports and practise a complete repair under a reasonable time constraint. Do not spend most preparation time on infrastructure-administrator tasks outside the application-developer role.