Passing the 2023 Certified Kubernetes Administrator (CKA) Exam

Last Tuesday, 3 January 2023, I took the Certified Kubernetes Administrator (CKAD) exam and passed it. I got a score of 86, which was higher than the required score of 66.

This was my second exam with the Linux Foundation. Previously, I took and passed the Certified Kubernetes Application Developer (CKAD) exam.

The Certified Kubernetes Administrator (CKA) exam tests an individual’s knowledge, skills, and ability to perform the tasks required of a Kubernetes administrator.

I took the latest version as the Linux Foundation continuously refreshes its exams. Currently, the exam uses Kubernetes v1.26. I also used the new remote desktop environment via the secure PSI browser.

This article describes my experience and strategy for preparing, studying, and taking the exam.

The CKA 2023 Domain & Competencies

You must show that you understand the following topics to pass the exam. Behind the subject, there is a percentage that indicates the weight of the topic on the exam.

• Storage (10%)
• Troubleshooting (30%)
• Workloads & Scheduling (15%)
• Cluster Architecture, Installation & Configuration (25%)
• Services & Networking (20%)

My exam preparation

I work with several Kubernetes clusters during my day job, so I have experience administrating clusters. To prepare for the exam, I used the following resources.

Udemy Certified Kubernetes Administrator Developer course

The course I used the most was the Udemy Certified Kubernetes Administrator (CKA) with Practice Tests from Mumshad Mannambeth. The course is excellent, and Mumshad explains every topic in great detail.

The real value for me was the included practice exams in combination with KodeKloud. Together with the online training, you get access to KodeKloud. KodeKloud is a virtual training environment that provides hands-on training in Kubernetes.

Killer.sh exam simulation

When you register for the exam at the Linux Foundation, you get two free Killer.sh simulator sessions. Each session, you have 36-hour access to a Kubernetes cluster where you have to answer the 24 exam questions.

Killer.sh states that their exam is more challenging than the actual exam. I disagree. They are the same. The difference is that the killer.sh exam got 22 questions, while on the actual exam, there are 17.

My study timeline

I started with the Udemy course, went through it from start to finish, and did all the practice labs. When I finished the course, I practiced the included mock exams several times on KodeKloud. I practiced them until I could get 100% and finish it in time.

After the course, I started the first Killer.sh simulation and answered all the questions. The first time I could only answer some of them and needed more time than the stated two hours. The Killer.sh simulation uses almost the same environment as the actual exam. It also uses a remote desktop in which you can start a terminal and a web browser.

I studied the solutions from Killer.sh and reiterated the topics in the Udemy course.

A couple of days before the exam, I started the second killer.sh simulation. Both sessions give you the same questions. I practiced it until I could solve all the questions within two hours.

I then took the exam and passed.

The exam

You take the exam by answering questions about scenarios that run on a couple of Kubernetes clusters. With this new version, you use the secure PSI browser, which connects you to a remote desktop with Ubuntu.

You perform the tasks using the terminal that you can start via the remote desktop. You can access the Kubernetes documentation via a web browser on the system and browse the Kubernetes website.

Some people reported lag when using the remote desktop. I did not have that experience. The remote desktop reacted quickly, and using the terminal and remote browser worked smoothly.

The exam consists of 17 scenarios with several sub-tasks you must complete in two hours.

Is the exam difficult? I don’t think so. Anyone with experience with Kubernetes should be able to answer all the questions. You are allowed to use the Kubernetes documentation.

I can’t disclose any of the questions because of the NDA, but I can say that if you can answer all of the Killer.sh questions within two hours, you are in a good spot for the exam.

The problem is time. You get two hours. This looks like a long time, but it isn’t. To pass this exam, you must be quick with the command line using kubectl. You don’t have enough time to search the answer of each question in the Kubernetes documentation.

The rest of this article focuses on how to improve your speed.

Improving speed by setup the terminal

With the previous version of the exam and environment, you had to create a kubectl alias and correctly configure your .vimrc. Luckily for us, this is already configured for you with the new environment.

When studying via the Killer.sh simulator, ensure you learn the correct keyboard shortcuts for copying and pasting from the terminal and web browser. I had more success with my Windows machine instead with my Macbook. Therefore, I used my Windows machine for the exam.

I still used the following two environment variables during the exam to speed up interacting with the Kubernetes cluster. I will show examples of how I used them later in the article.

export do="--dry-run=client -o yaml" 
export now="--grace-period 0 --force"

Improve speed by using imperative commands

Typically, in your production Kubernetes environment, you use declarative commands. You describe the desired state of a Kubernetes object via a yaml file and send that file to the Kubernetes API using kubectl. The cluster takes care of creating the object and reaching the desired state.

Now, you can get a significant speed improvement for the exam by using imperative commands instead. Let me show you an example.

Say that we want to create a Kubernetes ConfigMap called MyConfigMap in the namespace fire that contains a key of database_host with the value 192.168.16.1.

Using declarative syntax, you must create the following yaml file and apply it to the cluster. In this case, you must remember which apiVersion to use and format the file correctly.

A quicker way is to build the ConfigMap using imperative syntax. See below. It takes a lot less to type and is easier to remember. Another strategy is to copy an example from the Kubernetes documentation and change it.

k -n fire create cm MyConfigMap --from-literal=database_host=192.168.16.1

You can not build all Kubernetes objects via kubectl. For example, you cannot create a persistent volume and a persistent volume claim. Take a look at the help of kubectl kubectl create --help to see which objects you can build using the imperative syntax.

Combining imperative and declarative commands

Sometimes you get a task you cannot complete using a single imperative command — for example, the following question.

Create a pod called MyPod in namespace fire using the nginx:alpine image. Name the container in the pod MyPod-container.

We can create the pod using the following command.

k -n fire run MyPod --image=nginx:alpine

Now, this would work, but one thing that we can’t specify is the name of the container in the pod.

The solution is to create a yaml file using the imperative command. See the example below. Adding the --dry-run=client argument, kubectl does not run the command against the Kubernetes cluster but validates it. The -o yaml statement means we want to export the command using the yaml syntax.

k -n fire run MyPod --image=nginx:alpine --dry-run=client -o yaml > pod.yaml

This generates a file pod.yaml as shown below. Do you remember the requirement that the container is named “MyPod-container”? In this file, we can change the name of the container and create the pod using k apply -f pod.yaml.

Creating the yaml file using the dry-run argument and changing it

I used this technique with almost all the exam questions. First, generate a yaml file using an imperative command, change the file according to the requirements and create the resource using apply.

I showed in the Terminal section that I created two environment variables called do and now. The first one do contains --dry-run=client -o yaml. If we combine this with the imperative command for creating a pod, we get the following. This again saves a couple of keystrokes.

k -n fire run MyPod --image=nginx:alpine $do > pod.yaml

Deleting Kubernetes resources

Sometimes you need to delete a Kubernetes resource before you can update it. Deleting an object can take some time, typically 10 seconds. As you need all the time on the exam, you can speed it up by adding the arguments --force --grace-period 0 . This will directly delete the object.

Combining this with the new environment variable now we discussed earlier, we get the following command which saves another couple of keystrokes.

k -n fire delete pod MyPod $now

Skip difficult questions with a low rating

Some exam questions are more complex than others. Each question shows a weight (percentage) that indicates how much this question contributes to the exam score.

Try to answer as many questions as possible. This means skipping a question when it takes too much time. For example, when kubectl keeps complaining about syntax errors in your yaml, flag the question and continue with the next question.

You can always reevaluate if you have time left at the end of the exam.

Conclusion

I had fun with the exam and the course. I learned fascinating new things regarding Kubernetes from the course. You can also pass the exam if you have experience with running a Kubernetes cluster.

The most important thing is to practice becoming quick on the command line when using kubectl. There are a lot of resources available that can help you practice.

If you invest the time and practice enough, you will also pass the exam. Meanwhile, I will be busy studying for my next exam, Certified Kubernetes Security Specialist.