Premier Developer Consultant Julien Oudot partage ses recommandations pour se préparer et réussir l’examen de certification CKAD (Certified Kubernetes Application Developer).

En tant que consultant chez Microsoft, me concentrant sur les logiciels libres, j’ai récemment passé l’examen CKAD (Certified Kubernetes Application Developer) qui est très diffèrent par rapport aux certifications Azure auxquelles je suis plus habitué.

Tout d’abord, travailler dans une environnement Linux peut être intimidant lorsque l’on est plus confortable avec les interfaces graphiques ainsi que le système d’exploitation Windows. Heureusement, quelques commandes et astuces sont utiles afin d’être plus efficace lors de ce test.

Ensuite, il est important de souligner que cette certification n’est pas un simple questionnaire à choix multiples. En effet, elle est composée des sections suivantes :

• Une section d’instructions, sur la gauche de l’écran
• Une fenêtre Notepad qui peut être réduite ou affiché en haut à droite de l’écran
• Un terminal Linux au centre
• Un seul onglet de navigateur Internet, à partir duquel il est possible de naviguer vers la documentation (https://kubernetes.io/docs/). Il est aussi possible d’ouvrir les pages dont les adresses commencent par https://kubernetes.io/blog/ ou bien https://github.com/kubernetes, mais les pages les plus utiles sont celles préfixées par https://kubernetes.io/docs/).

Toutes les réponses doivent être fournies dans le terminal, en créant des objets Kubernetes ou bien en écrivant les bonnes informations dans un fichier texte (par exemple, une erreur retournée par un pod).

Le test dure 2 heures et il y a 19 questions qui sont, en réalité, des problèmes à résoudre.

Outils pour répondre aux problèmes

Pour résoudre les problèmes posés, voici une liste des outils les plus importants que j’ai été amené à utiliser durant le test :

• kubectl explain <object_name>.spec – qui montre quels champs peuvent être utilisés dans la définition des objets Kubernetes au format YAML. Il est par exemple utile de savoir si un « readiness probe » doit être déclaré au même niveau que le pod ou au niveau du container. Il est aussi possible d’ajouter le paramètre –recursive à la commande pour afficher tous les niveaux de la hiérarchie YAML. Cette option peut cependant être à éviter car est relativement verbeuse.
• La page de documentation de la commande kubectl. Pendant le test, il ne sera pas seulement nécessaire de travailler de manière déclarative avec les fichiers YAML, mais il faut également utiliser la syntaxe impérative avec la commande kubectl. Afin de vérifier la syntaxe, il est important de pouvoir naviguer rapidement jusqu’à la documentation puisqu’une seule page web peut être ouverte durant le test. Depuis https://kubernetes.io/docs/, cliquer sur Home – Reference – kubectl CLI – kubectl Commands – kubectl Commands Reference.
• La fonctionnalité de recherche de la page https://kubernetes.io/docs/. J’ai utilisé cette fonctionnalité afin de trouver des exemples de définitions au format YAML. Lorsque seulement quelques champs sont nécessaires, la commande kubectl explain peut être suffisante, mais dans le cas plus complexes comme les volumes ou les configs map, il est souvent plus rapide de voir un exemple complet. Dans ce cas, la recherche de l’objet spécifique à déclarer peut s’avérer être un gain de temps important.

Commandes Linux importantes

Il n’est pas nécessaire de connaitre des commandes Linux avancées pour réussir cet examen. Ci-dessous se retrouvent quelques exemples utilisés lors de mon test :

• Écrire le résultat d’une commande dans un fichier

Exemple : kubectl get pods > result.txt

Lorsqu’il est demandé de sélectionner une partie spécifique du résultat de la première commande, la méthode que j’ai choisie était de copier la partie spécifique manuellement et de la rediriger vers le fichier de résultat :

Exemple : echo ‘’chaine de caractères à écrire‘’ > result.txt

Une manière plus élégante aurait été d’utiliser grep, mais je n’étais pas assez à l’aise avec cette commande, et il n’y avait pas assez de temps pour regarder sa documentation en détail. Quelqu’un d’habitue à utiliser cette commande gagnera un temps non négligeable pour sélectionner et écrire une information spécifique dans un fichier de sortie.

Exemple : kubectl describe pods <mypod> | grep –context=10 Events > result.txt

• Savoir utiliser l’image busybox pour investiguer les erreurs. L’image busybox ainsi que sa documentation se trouvent au lien suivant : https://hub.docker.com/_/busybox. Particulièrement, après avoir démarré une session dans le terminal d’un pod busybox, il est important de savoir comment tester la communication avec d’autres pods.

Exemple : wget -O- POD_IP:8080 #

Minimiser son utilisation du clavier

Voici les premières commandes que j’ai saisies dès le début de l’examen :

• Export KUBE_EDITOR=nano – C’est juste une préférence personnelle, mais je n’avais pas utilisé VI[M] depuis longtemps, j’ai donc préféré utiliser Nano. Cette variable d’environnement KUBE_EDITOR est utilisée lors de l’exécution de la commande kubectl edit. Grâce à cette commande, le YAML correspondant à l’objet Kubernetes édité sera ouvert dans Nano par défaut.
• alias k=kubectl – Bien entendu, il est nécessaire de saisir la commande kubctl de nombreuses fois durant le test. Puisque cette dernière est relativement longue, un alias était très utile.
• alias kx=”kubectl explain” – comme expliqué précédemment, kubectl explain est une commande qu’il sera utile de saisir un certain nombre de fois, la raccourcir est donc recommandé.

De plus, pour d’éviter la création de fichiers YAML à partir de zéro, l’utilisation des paramètres –dry-run -o yaml > myfile.yaml permet de gagner beaucoup de temps. Ces paramètres peuvent être ajoutes après une commande kubectl create/run pour écrire la définition YAML de l’objet. Il faudra ensuite la modifier en utilisant Nano ou VI. Cette astuce est très utile lorsqu’on ne connait pas toutes les options à utiliser impérativement avec la commande kubectl pour créer un objet Kubernetes avec tous les attributs demandés par le scenario.

Il est aussi possible d’utiliser kubectl get <any_resource> -o yaml > myfile.yaml, puis modifier le fichier YAML, puis finalement le déployer  kubectl apply -f myfile.yaml. Cette approche permet de ne changer que quelques paramètres d’un objet Kubernetes déjà existant. Notez qu’une commande encore plus rapide serait kubectl edit, mais en fonction du problème posé, il peut être nécessaire de créer une autre instance d’un objet avec seulement quelques différences.

Pour finir, il est recommandé d’utiliser les types d’objets Kubernetes raccourcis autant que possible : svc au lieu de services, po au lieu de pods, rs au lieu de replicasets, …

Utilisation du copier/coller

Copier et coller du texte n’est pas aussi facile qu’attendu. Tout d’abord, les raccourcis clavier sont différents pour les candidates accédant au test depuis un système d’exploitation Windows. (Control-c and control-v ne fonctionneront pas dans le terminal ou dans le Notepad). Les nouveaux raccourcis seront control-insert pour copier et shift-insert pour coller.

De plus, lors de la copie d’exemples depuis la documentation dans la fenêtre Notepad, il est probable que l’indentation ne soit pas juste. Comme tout développeur habitué à travailler avec YAML sait, il est primordial d’avoir le bon nombre d’espaces au bon endroit. Pour ce faire, une bonne approche consiste à :

• Copier les lignes ciblées depuis la documentation dans la fenêtre Notepad. Notez que le nombre de lignes qu’il est possible de copier est assez petit, vous ne copierez donc pas le YAML en entier, mais plutôt une section particulière.
• Vérifier l’indentation dans la fenêtre Notepad
• Copier depuis Notepad et coller dans le terminal (Nano/VI)
• Vérifier l’indentation une dernière fois

Préparation technique

Au-delà des astuces décrites ci-dessus, il est important d’être bien préparé pour passer cet examen avec succès. La bonne nouvelle est que toutes les compétences nécessaires pour réussir font partie du dépôt de code GitHub suivant :  https://github.com/dgkanatsios/CKAD-exercises. Dans le cadre de ma préparation, le contenu de ce dépôt a vraiment eu une valeur inestimable et être à l’aise avec tous les concepts qu’il couvre m’a permis de réussir ce test de certification.

Être précis est aussi important qu’être rapide

Ce test est long, et il est fort probable que vous n’ayez pas assez de temps pour résoudre l’intégralité des problèmes posés. Vous devez donc vous assurer qu’un maximum de réponses apportées aux problèmes poses sont justes. Cependant, il ne faut pas passer trop de temps pour valider ses réponses pour être capable d’en traiter le plus possible. Déterminer combien de temps passer sur l’étape de validation sera donc le résultat de votre jugement.

Par exemple, lors d’un scenario ou il faut résoudre un problème de communication entre deux pods, si le symptôme initial est une erreur venant d’un pod A indiquant qu’il ne peut communiquer avec le pod B, il sera nécessaire de vérifier que cette erreur disparait après les mesures correctives. Mais il n’est pas forcement nécessaire de déployer un pod busybox pour vérifier la communication entre pod A et pod B.

Conclusion

Passer ce test apporte de la satisfaction et sa réussite signifie que vous avez réussi à maitriser votre temps. Être un expert Linux n’est pas requis, mais savoir réagir rapidement et habilement avec la commande kubectl et le format YAML est nécessaire.

Dans mon cas, je n’ai pas eu le temps de répondre à 5 questions et je pensais que ce nombre était trop important pour avoir le score suffisant. Heureusement, la plupart des réponses fournies étaient justes, ce qui m’a permis de réussir à décrocher cette certification dès le premier essai avec un score de 72% (pour un score minimum requis de 66%).