Préparer sa certification CKAD : et la réussir du premier coup

La Certified Kubernetes Application Developer (CKAD) permet aux développeurs de valider et certifier leurs connaissances de conception, d’analyse, de monitoring et de debug d’applications cloud-native déployées sur un écosystème Kubernetes. C’est un examen développé par la Cloud Native Computing Foundation (CNCF) et organisé par The Linux Foundation.

Il consiste en 15-20 questions pratiques et se déroule sur 2 heures. Le candidat est surveillé tout au long, en ayant accès à deux onglets ; un terminal et la documentation Kubernetes. Une fois la certification obtenue, elle est valable 3 ans.

Après quelques semaines de préparation, j’ai passé ma certification CKAD et je l’ai réussie dès la première tentative. Je vous explique comment vous y préparer au mieux dans cet article.

Contenu

Le contenu de l’examen change régulièrement, il a été globalement revu lors du passage à la version 1.19 de Kubernetes. Pour la version actuelle (v1.20), la certification se focalise sur la maîtrise des concepts Kubernetes suivants :

  • Core Concepts (13%)

    • Comprendre le fonctionnement des primitives de l’API Kubernetes
    • Créer et configurer des Pods

  • Configuration (18%)

    • Comprendre le fonctionnement des ConfigMaps
    • Comprendre le fonctionnement des SecurityContexts
    • Définition des ressources d’une application
    • Création et utilisation des Secrets
    • Comprendre le fonctionnement des ServiceAccounts

  • Multi-Container Pods (10%)

    • Comprendre l’architecture multi-conteneur des Pods (patterns : ambassadeur, adaptateur, sidecar)

  • Observability (18%)

    • Comprendre le fonctionnement des LivenessProbes & ReadinessProbes
    • Manipulation des logs d’un conteneur
    • Monitoring d’applications dans Kubernetes
    • Debugging dans Kubernetes

  • Pod Design (20%)

    • Déploiements et RollingUpdate
    • Déploiements et rollbacks
    • Comprendre le fonctionnement des Jobs & CronJobs
    • Manipulation des Labels, Selectors & Annotations

  • Services & Networking (13%)

    • Comprendre le fonctionnement des Services
    • Manipulation des NetworkPolicies

  • State Persistence (8%)

    • Utilisation des PersistentVolumeClaims pour le stockage des données

Formations

Pour ceux et celles qui ne sont pas familiers avec le concept d’orchestration de conteneurs, la première étape consisterait à suivre une formation en ligne.

De nombreux cours et formations existent, permettant de mieux comprendre la philosophie et le fonctionnement de Kubernetes lors de la conception et le déploiement d’applications sur des clusters.

Parmi celles qui sont les plus populaires et qui permettent de préparer au mieux sa certification CKAD :

  1. Certified Kubernetes Application Developer (CKAD) with Tests (Udemy)

    1. Avantages :
      1. des exercices, de difficulté bien adaptée, après chaque leçon ou section permettant de renforcer sa compréhension
      2. des labs et mocks exams d’une difficulté similaire à celle de l'examen CKAD
      3. des sections importantes non couvertes par l’examen. Notamment les Taints & Tolerations ainsi que la gestion de persistance avec les Stateful Sets
    2. Inconvénients :
      1. quelques bugs aléatoires, mais rares, lors de l’utilisation du terminal Katacoda
      2. utilisation d’une vieille version de Kubernetes (v1.16) dans les labs de certaines sections
      3. une infrastructure vite surchargée, avec peu de ressources pour supporter tous les élèves inscrits

  2. Certified Kubernetes Application Developer (CKAD) (ACloudGuru)

    1. Avantages :
      1. configuration et accès à un cluster privé
      2. infrastructure robuste
    2. Inconvénients :
      1. la faible difficulté des exercices et des mocks exams est non représentative du niveau requis lors de l’examen
      2. contenu exactement limité à celui couvert par l’examen CKAD

  3. Certified Kubernetes Application Developer (CKAD) Course (Matthew Palmer) une alternative moins coûteuse pour se former aux bases de Kubernetes ayant comme support d'entraînement des scénarios sur KataKoda :

    1. https://www.katacoda.com/fabito/
    2. https://www.katacoda.com/ckad-prep/

Exercices & simulateur d’examen

En complément des labs et mock exams à faire lors des formations, KodeKloud propose un accès gratuit à des exercices interactifs sur un thème Game of Thrones, Game Of Pods.

Un simulateur d’examen peut être une alternative plus intéressante pour ceux et celles qui ont déjà de l’expérience avec Kubernetes et veulent s’exercer sur des problèmes plus avancés, le tout dans une configuration quasi identique à celle de l’examen.

Killer Shell, simulateur payant pour les exams CKAD / CKA / CKS propose deux sessions, chacune de 36h, où on peut s'entraîner à résoudre une vingtaine de questions sur 2 heures.

A la fin du temps imparti, on peut voir sa note et accéder aux solutions. À noter que les questions sont d’une difficulté plutôt supérieure à celle de l’examen CKAD mais ne changent pas d’une session à l’autre.

Pour aller (très) vite

Être suffisamment familier avec les principes et fondamentaux de Kubernetes est bien entendu primordial pour passer la certification. Mais être rapide lors de la manipulation des différentes commandes et différents objets primitifs pendant l’examen permet de le faire, en étant beaucoup plus confiant. Idéalement, il serait sage de cibler un score plus important que les 66% nécessaires à sa validation. Cela est tout à fait atteignable en trouvant le bon équilibre, qui sera propre à chacun, entre organisation du temps et rapidité.

Les questions que l’on peut rencontrer lors de la certification, sont notées par poids de 2 à 12 et varient du facile au très compliqué.

Elles peuvent être courtes et nécessiter qu’une ou deux actions, souvent en utilisant des commandes itératives. Comme elles peuvent être assez longues et décrire tout un scénario d’actions et de manœuvres à réaliser. Il est donc indispensable, dans un premier temps, de ne pas perdre beaucoup de temps sur les questions qui seraient difficiles ou qui ne rapporteraient que peu de points.

La plateforme proposée par Linux Foundation met à disposition un bloc-notes que l’on peut ouvrir sur le même écran que le terminal. Très pratique pour noter les questions que l’on préfère momentanément sauter, ou celles qui nous posent souci, afin d’y revenir par la suite avant la fin des deux heures d’épreuve.

Commandes impératives

Un ratio de 20 à 30% de questions, ou parties de questions, peuvent être facilement réalisées sans avoir à éditer le moindre fichier YAML.

Les commandes impératives de kubectl ci-dessous sont indispensables pour gagner du temps :

# change default namespace for current context
kubectl config set-context --current --namespace=planets

# delete a resource without waiting
kubectl delete po <pod-name> --wait=false
# search in all namespaces (--all-namespaces)
kubectl get pods -A

# define key for configmap created from file
kubectl create cm configmap4 --from-file=specialKey=config4.txt

# define requests & limits for pod
kubectl run nginx --image=nginx --requests='cpu=100m,memory=256Mi' --limits='cpu=200m,memory=512Mi'

# define service account, a container port and env var for a pod
kubectl run nginx --image=nginx --serviceaccount=myuser --port=66 --env=var1=val1

# start pod that runs a specific action (adds it to "args" property automatically)
kubectl run busybox --image=busybox --restart=Never -- /bin/sh -c 'i=0; while true; do echo "$i: $(date)"; i=$((i+1)); sleep 1; done'

# start pod that runs a specific action (adds it to "command" property automatically)
kubectl run busybox --image=busybox --command --restart=Never -- /bin/sh -c 'i=0; while true; do echo "$i: $(date)"; i=$((i+1)); sleep 1; done'

# run command and automatically delete the pod 
# (--rm should only be used for attached containers, meaning : when using -it)
kubectl run busybox --image=busybox -it --rm --restart=Never -- echo 'hello world'

# run pod and label it in one command
kubectl run nginx2 --image=nginx --restart=Never --labels=access=granted --rm -it -- curl http://nginx

# create ResourceQuota
kubectl create quota myrq --hard=cpu=1,memory=1G,pods=2

# show labels for pods or nodes
kubectl get po/nodes --show-labels

# change already set label
kubectl label po nginx2 app=v2 --overwrite

# get all pods with specific label (app)
kubectl get po -L app

# get only the "app=v2" pods
kubectl get po -l app=v2
OR
kubectl get po --selector=app=v2

# remove app label from the pods
kubectl label po nginx1 nginx2 nginx3 app-
OR
kubectl label po nginx{1..3} app-

# label pods that have different label values
kubectl label pod -l "type in (worker,runner)" protected=true

# annotate resources
kubectl annotate po nginx1 nginx2 nginx3 description='my description'

# remove annotations
kubectl annotate po nginx{1..3} description-

# autoscale deployment
kubectl autoscale deploy nginx --min=5 --max=10 --cpu-percent=80

# create a job that executes a command
kubectl create job busybox --image=busybox -- /bin/sh -c 'echo hello;sleep 30;echo world'

# create pod AND expose it via a service
kubectl run nginx --image=nginx --restart=Never --port=80 --expose

# check endpoints created for exposed pod
kubectl get ep nginx

# copy files/directories from pod's container to local folder and vice versa
kubectl cp <some-namespace>/<some-pod>:/tmp/foo /tmp/bar
kubectl cp /tmp/foo_dir <some-pod>:/tmp/bar_dir -c <specific-container>

Vim

L’utilisation de Vim, plutôt que nano ou un autre éditeur, est très fortement conseillée. Elle a été capitale dans ma préparation et la réussite de la certification CKAD. A minima, les commandes de base ne doivent pas être un problème pour vous (changement de mode, sauvegarder, supprimer/copier/coller/couper, undo/redo, rechercher ...).

Elle vous évitera également quelques soucis d’incompatibilité entre le navigateur et le terminal Linux Foundation (ceux du copier/coller notamment) qui peuvent considérablement vous ralentir.

Voici un cheat-sheet non exhaustif :

# Configure VIM to better handle YAML files indentation
vim ~/.vimrc
set sw=2 ts=2 sts=2 et nu

# Some useful Vim commands
w ==> jump by start of words
e ==> jump by end of words
b ==> jump backward by words
0 ==> (zero) jump to the start of the line
$ ==> (dollar) jump to end of line
gg ==> go to top of page
G ==> go to bottom of page
dd ==> delete current line
y ==> yank/copy current line
P ==> paste content before cursor
p ==> paste content after cursor
i ==> enter insert mode to input text in current cursor location
a ==> enter insert mode and move cursor to append to the existing line
u ==> undo last action
ctrl + r => redo last action
shift + v ==> to enter visual line mode
v ==> to visually select multiple lines
# in VISUAL mode
arrows OR h, j, k, l ==> to move the cursor

Si vous êtes toujours réfractaires à l’idée d’utiliser exclusivement Vim, les liens ci-dessous sont une première initiation pour commencer tout en douceur :

Vim Crash Course | How to edit files quickly in CKAD / CKA exam

Une vidéo dans le thème, permettant en 30 minutes de faire un tour assez complet des commandes les plus importantes pour réussir en toute confiance sa certification.

vi / vim graphical cheat sheet
L’image “vim graphical” assez connue, en AZERTY, qui permet de visualiser toute la richesse des commandes Vim.

YBlog - Learn Vim Progressively
De prime abord, Vim peut sembler intimidant. Cet article propose une façon alternative, plus progressive, pour mieux l’appréhender.

Interactive Vim tutorial
Vim Casts
D’autres liens pour s’exercer et apprendre à utiliser Vim efficacement.

Autocompletion, aliases & raccourcis

# setup autocomplete in bash into the current shell, bash-completion package should be installed first.
source <(kubectl completion bash)
# add autocomplete permanently to your bash shell.
echo "source <(kubectl completion bash)" >> ~/.bashrc 

# enable completion for k aliases
alias watch='watch ' >> ~/.bashrc
alias k=kubectl >> ~/.bashrc
complete -F __start_kubectl k >> ~/.bashrc

# speed up imperative commands
alias kc='k create -f'
alias kgp='k get pod -owide'
alias kn='k config set-context --current --namespace'
export do='--dry-run=client -oyaml'
alias krm='k delete pod --force --grace-period=0'
alias kwget='k run busy --rm -it --image=busybox --restart=Never -- wget -O- --timeout 2'

Documentation Kubernetes

Lors de l’examen, vous avez uniquement le droit d’accéder à la documentation Kubernetes. Ajoutez ces liens à vos favoris pour rapidement retrouver les sections les plus importantes ainsi que leurs spécifications en YAML, quand les commandes impératives ne vous permettent pas de créer un primitif Kubernetes en une seule ligne :

kubectl Cheat Sheet
PV Persistent Volumes | Kubernetes
PVC Persistent Volume Claims | Kubernetes
Storage Class | Kubernetes
configMapRef ConfigMap | Kubernetes
secretRef Secrets | Kubernetes
Init Containers | Kubernetes
Security Context capabilities | Kubernetes
Liveness/Readiness Probes | Kubernetes
Network Policies | Kubernetes
Jobs | Kubernetes
CronJob | Kubernetes

Pratiquer, pratiquer, pratiquer

Il n’y a pas réellement de secrets pour réussir sa certification CKAD. Travailler au quotidien dans un environnement Kubernetes aide beaucoup, mais rien ne vaut une pratique régulière pendant une ou deux semaines sur les exercices/labs/mock exams proposés par les formations et simulateurs listés plus haut.

Pour se familiariser davantage avec les commandes impératives de kubectl, les liens ci-dessous vous seront précieux :
https://github.com/dgkanatsios/CKAD-exercises
https://www.katacoda.com/liptanbiswas/courses/ckad-practice-challenges/

Bonne préparation !


Vous avez trouvé cette publication utile? Cliquer sur