How to finish the Kubernetes Certification Exam in time

In this blog we discuss how to effectively manage your time during the Kubernetes Certification Exams. These are tips I gathered from my experience helping 1000s of students prepare for the Certified Kuberenetes Courses at KodeKloud.

The information provided in this blog are based on the information provided in the Candidate Handbook and Exam Tips documentations available on the CNCF website.

The Kubernetes certification exams are practical and consist of 19 (CKAD)to 24(CKA) questions. And you have 2 Hour (CKAD) / 3 Hours (CKAD) to solve these questions. The questions are scenario based and you are to complete the required tasks in the given time. Since the exams are practical, it is highly unlikely that you will get to solve all the tasks in the given time. So it is important to manage your time effectively to attempt and solve enough questions to clear the exam. In this blog we will look at different techniques to manage time during the exam.

Attempt All Questions

During the exam, you are presented with a set of questions. Some of which may be very easy, some that makes you think a little bit, and some that you have no clue about, hopefully not too many of that. And they are not there in any particular order.

You may have easy or tough questions in the beginning or towards the end. Now you don’t have to get all of it right. You only need to solve enough to gain the minimum required percentage to pass the exam. So it is very important to attempt all of the questions. You don’t want to get stuck in any of the early tough questions, and not have enough time to attempt the easy ones that come after.

You have the option to attempt the questions in any order you like. So you could skip the tough ones and chose to attempt all the easy ones first. Once you are done, if you still have time, you can go back and attempt the ones you skipped.

Don’t get stuck!

The second tip is not get stuck on any question. Even for a simple one. For example you are attempting to solve a question that looks simple. You know what you are doing, so you make an attempt. The first time you try to execute your work, it fails.

You read the error message and realize that you had made a mistake, like a typo. So you go back and fix it and run it again.

This time you get an error message, but you are not able to make any sense out of it. Even though that was an easy question, and you knew you could do it, if you are not able to make any sense out of the error message, don’t spend any more time troubleshooting or debugging that error. Mark that question for review later, skip it and move on to the next.

Now, I KNOW that urge to troubleshoot and fix issues. But this is not the time for it. Leave it to the end and do all the troubleshooting you want after you have attempted all the questions.

Be good with YAML

The third tip, is to be really good with YAML. You must spend enough time practicing your definition files in advance. If, for each question, you are having to go through each line of your YAML file and fix the indentation errors, you are not going to be able to make it through all questions. Your YAML files don’t have to look pretty. Because nobody is going to look at them. I am guessing that the work is evaluated automatically, so only the end result is evaluated and not how pretty your YAML files are.

So even if your file looks like this one on the right, where as it should have looked like the one on the left, it’s still fine as long as the structure of the file is correct. And that you have the right information in the file and are able to create the required kubernetes object using the file. For that you need to get your YAML basics right. If you are a beginner, check out the coding exercises at KodeKloud that helps you practice and get good with YAML:

YAML Practice Exercises on KodeKloud

Go here to access the YAML practice exercises right in your browser

Use aliases, shortcuts and imperative commands

Finally, use aliases or shortcuts to get things done quickly. These can save you few seconds on each command, accumulating to a few extra minutes towards the end.

po for PODs
rs for ReplicaSets
deploy for Deployments
svc for Services
ns for Namespaces
netpol for Network policies
pv for Persistent Volumes
pvc for PersistentVolumeClaims
sa for service accounts

Avoid creating/editing YAML files

Consider using imperative commands whenever possible to save you time instead of building/editing YAML definition files. Here are some tricks.

Create an NGINX Pod

kubectl run --generator=run-pod/v1 nginx --image=nginx

Generate POD Manifest YAML file (-o yaml). Don’t create it( — dry-run)

kubectl run --generator=run-pod/v1 nginx --image=nginx --dry-run -o yaml

Create a deployment

kubectl run --generator=deployment/v1beta1 nginx --image=nginx

Generate Deployment YAML file (-o yaml). Don’t create it( — dry-run)

kubectl run --generator=deployment/v1beta1 nginx --image=nginx --dry-run -o yaml

Generate Deployment YAML file (-o yaml). Don’t create it( — dry-run) with 4 Replicas ( — replicas=4)

kubectl run --generator=deployment/v1beta1 nginx --image=nginx --dry-run --replicas=4 -o yaml

Save it to a file — (If you need to modify or add some other details)

kubectl run --generator=deployment/v1beta1 nginx --image=nginx --dry-run --replicas=4 -o yaml > nginx-deployment.yaml

Read more about it here https://kubernetes.io/docs/reference/kubectl/conventions/

Similarly below are some examples of imperative management using the kubectl create command:

Available Commands:
  clusterrole         Create a ClusterRole.
  clusterrolebinding  Create a ClusterRoleBinding 
  configmap           Create a configmap 
  deployment          Create a deployment with the specified name.
  job                 Create a job with the specified name.
  namespace           Create a namespace with the specified name
  poddisruptionbudget Create a pod disruption budget 
  priorityclass       Create a priorityclass with the 
  quota               Create a quota with the specified name.
  role                Create a role with single rule.
  rolebinding         Create a RoleBinding 
  secret              Create a secret using specified subcommand
  service             Create a service using specified subcommand.
  serviceaccount      Create a service account 

Refer to this link for more on imperative commands: https://kubernetes.io/docs/concepts/overview/object-management-kubectl/imperative-command/

Access the full course for the Certified Kubernetes Application Developer here

Kubernetes Certification Course