I’ve never been a huge fan of IT Certifications. I tend to believe that one’s ability to search for information associated with a good practical expertise is much more valuable than plain memorization. On the other hand, some certifications force us to go the extra mile and to study an unusual topic. That singularity captivates me.
Following that path, these last months I focused on two different Kubernetes certifications: CKA (Certified Kubernetes Administrator) and CKAD (Certified Kubernetes Application Developer). Even though I wouldn’t call myself a DevOps/SR engineer, they seemed to be the natural path for an application developer working with containers and cloud computing. By the way, I strongly recommend taking these two, specially the CKAD because “Earners of this designation demonstrated the skills, knowledge and competencies to perform the responsibilities of a Kubernetes Application Developer. Earners are able to define application resources and use core primitives to build, monitor, and troubleshoot scalable applications and tools in Kubernetes”.
Challenges of Kubernetes Certifications
As I mentioned, I don’t think that memorization itself is a good proxy for one’s ability to deal and perform on a specific technology/tool and here is where the CKA(D) certifications shine. The test sponsored by The Linux Foundation consists of 20 real world practical challenges, i.e., It is requested to log in into a terminal and issue commands to solve problems, install applications, expose endpoints, and etc. In the end of the day, they test the ability to work with Kubernetes without having to ask boring memorization questions.
The good thing about practical exams is that we can leverage our working experience and use our “googling” ability to solve the problems; however, we can’t guesstimate as we could do in a multiple choice exam. Therefore, it’s really important to be aware of the time remaining during the exam and, of course, be familiar with Linux and kubernetes. It isn’t an easy exam but it’s feasible to pass studying for one to two months.
Study guide for the CKA and CKAD
There are plenty of study books and articles about these topics and they are all really useful; I’d like to focus more on the real world scenarios that you could face, though. If you can do all of them from scratch in a Linux environment, you would be halfway there:
- Install a Kubernetes cluster (1 master and 1+ worker node) from scratch using kubeadm
- Configure a new worker node on an existing cluster
- Configure security, networking and credentials on an existing cluster
- Install and configure a service mesh (Istio/Linkerd)
- Deploy an application (plain pod, replicaset and deployment)
- Deploy jobs (plain job and a cronjob)
- Expose applications (using services, ingress and service mesh)
- Creating, managing and using volumes, persistent volumes, persistentVolumeClaims and storageclasses.
- Configure networking permissions, redirects and firewalls using NetworkingPolicies
- Monitor, log and debug applications (view and extract logs, execute a command on a running container and etc)
Why I think it’s important to be a certified professional
Technology stacks have been changing really fast lately, so being a certified professional couldn’t help that much with a new job opportunity. To be honest, services and applications are being deployed using a combination of hundreds of different technologies, servers, OSs, frameworks, and etc, so, having a badge couldn’t help more than 10% during job hunting.
The most important thing about being a certified professional consists of the studying process. The fact that we don’t know what is going to be “asked” during the exam forces us to study those specifics and singular topics, that tiny hidden feature that could save us a lot of time or increase the application performance when needed. One clear example for me is the Java “volatile” keyword. It’s not a common keyword (specially for a garbage collected language) but it has it’s usage and it could be really useful when writing and/or debugging multi-threading code. The fact that this volatile concept is extensively covered in the Java Certification Exam (JCP) forced me to practice it in a real world scenario. I could have been coding avoiding this keyword and I could have spent my entire career without knowing about it, but that would mean a lack of knowledge and one fewer tool in my toolbox. The Java OCP forced me to know, study, and practice it. And for me, this is the real value of my Java certification.