Aller au contenu
DevSecOps Logo DevSecOps Logo DevSecOps
Docs
Blog
Blog

Passer les certifications Kubernetes

logo kubernetes

Bien décidé à passer la certification CKA et mon budget perso est assez limité, donc j’ai décidé de mettre en place un projet permettant de provisionner de manière flexible des clusters Kubernetes. Je ne cherche pas à rivaliser avec KubeSpray ou les bacs à sable payant, mais de provisionner gratuitement et rapidement des machines avec vagrant en se collant aux conditions de passage de la certification. J’ai décidé de vous partager mon projet, qui réponde au nom de CKASandBox ↗. Il est à ces débuts et je fais appel à votre bonne volonté pour me proposer vos idées voir vos contributions.

Idées en cours d’écriture

Parmi les fonctionnalités que je compte ajouter, la possibilité de déclencher des pannes de manière aléatoire sur le cluster provisionné.

Fonctionnement de CKASandBox

Pour le moment CKASandBox ↗ utilise vagrant, libvirt et Ansible pour provisionner des machines virtuelles. Les machines sont construites avec des boxes Ubuntu 20.04 pour se retrouver dans les conditions de la certification. Pour faciliter l’utilisation, j’ai ajouté une VM se nommant controller sur laquelle est installé HaProxy comme load-balancer, kubectl et quelques autres outils pour manipuler le cluster.

Pour ceux qui ne connaissent pas Ansible et Vagrant je vous renvoie à mes documentations :

Pour utiliser CKASandBox ↗, il faut disposer d’une machine comptant un minimum de 5 Cores et 8Gb de RAM, mais plus serait le bienvenu. Personnellement j’utilise mon pc Windows sur lequel j’ai une machine hyper-v avec 6 cores et 12 Gb de RAM. Il faudra installer Vagrant, Ansible, Libvirt en prérequis (je les documenterais dans le projet par la suite)

Pour le moment j’ai documenté la création d’une VM Centos sous hyper-v contenant tout ce qu’il faut pour faire fonctionner ce projet : libvirt et ansible. J’ajouterais dans les prochains ce qu’il faut pour d’autre OS, mais pas WSL !!!

Installation du projet

Il suffit de cloner le projet :

Terminal window
git clone git@github.com:stephrobert/CKASandBox.git

Dans les premières lignes du Vagrantfile se trouve des variables permettant de configurer le cluster :

# -*- mode: ruby -*-
# vi: set ft=ruby :


Vagrant.configure(2) do |config|


  base_ip_str = "10.240.0.1"
  number_master = 1 # Number of master nodes kubernetes
  cpu_master = 2
  mem_master = 1792
  number_worker = 1 # Number of workers nodes kubernetes
  cpu_worker = 1
  mem_worker = 1024
  config.vm.box = "generic/ubuntu2204" # Image for all installations
  kubectl_version = "1.25.3-00"
  kube_version = "1.25.3-00"

Il est ainsi de possible de :

  • de choisir le nom de la boxe sources
  • paramétrer le nombre de nœuds master et worker
  • paramétrer les ressources des nodes
  • de choisir les versions des principaux composants (attention à bien prendre composants compatibles entre eux!).

Pour provisionner un cluster, il suffit de changer les paramètres et de lancer la commande vagrant up. Par contre, comme j’ai fait le choix de m’appuyer l’inventaire dynamique de vagrant il faudra bien lancer le provisionnement de tous les noeuds. En effet, vagrant reconstruit l’inventaire à chaque lancement de commande voir de lancements de playbooks. Si à un moment donné je me rends que cela contraint le projet je ferai les changements adéquats.

Pour se connecter au cluster il faut préalable ajouter la ligne suivante dans votre fichier /etc/hosts :

Terminal window
10.240.0.10 controller

Ensuite on se connecte en ssh (en utilisant la clé id_ed25519):

Terminal window
ssh controller
vagrant@controller:~$

Le compte utilisateur est vagrant bien sur qui a les droits sudo.

Installation du cluster Kubernetes à la main

Pour le moment pour monter le cluster, il faut passer les commandes kubeadm.

Création des masters nodes

Sur le noeud master:

Terminal window
vagrant@controller:~$
ssh master1
sudo su -
root@master1:~#
kubeadm init --pod-network-cidr=192.168.0.0/16 --control-plane-endpoint "10.240.0.10:6443" --upload-certs --cri-socket unix:///run/containerd/containerd.sock

Les choix du cidr des pods est fait pour accéder la plupart des CNI : calico. Le point d’entrée du control-plane est celui de l’haproxy (je dois encore paramétrer sa configuration). Si vous êtes limité en terme de ressources cpu et mem il faudra ajouter l’option --ignore-preflight-errors !

Création des workers nodes

Sur le worker il faudra lancer la commande fournie en sortie du kubeadm sur le noeud master (avec l’option —ignore-preflight-errors=NumCPU,Mem si besoin)

Pour copier la configuration du cluster sur le controller :

Terminal window
vagrant@controller:~$
ssh worker1
sudo su -
root@worker1:~#
kubeadm join 10.240.0.10:6443 --token haw1ta.549yj2ch83rja85b \
        --discovery-token-ca-cert-hash sha256:d40835804cbf765d6d1a1a98bf7bba9baeff88f0b126505d984e54bb2a084b71 --ignore-preflight-errors=NumCPU,Mem --cri-socket unix:///run/containerd/containerd.sock

Gestion du cluster depuis le controller

Il faut copier la configuration du cluster sur le controller :

Terminal window
ssh controller
ssh master1 sudo cat /etc/kubernetes/admin.conf > ~/.kube/config
kubectl get nodes -A
NAME      STATUS     ROLES                  AGE     VERSION
master1   NotReady   control-plane,master   2m31s   v1.25.3
worker1   NotReady   <none>                 26s     v1.25.3

Installation du CNI

On va prendre calico :

Terminal window
ssh controller
kubectl apply -f https://docs.projectcalico.org/manifests/calico.yaml


...
deployment.apps/calico-kube-controllers created
serviceaccount/calico-kube-controllers created
poddisruptionbudget.policy/calico-kube-controllers created

Attendez une bonne minute le temps que tout se mette en place :

Terminal window
vagrant@controller:~$
kubectl get nodes
NAME      STATUS   ROLES           AGE   VERSION
cplane1   Ready    control-plane   20m   v1.25.3
worker1   Ready    <none>          11m   v1.25.3

Les nodes sont Ready !

Installation du cluster Kubernetes avec Ansible

Il suffit d’utiliser la commande vagrant push. Au bout de quelques minutes le cluster devrait être disponible.

Terminal window
vagrant push


....

Dans une autre session :

Terminal window
ssh controller


vagrant@controller:~$ kubectl get nodes
NAME      STATUS   ROLES           AGE   VERSION
master1   Ready    control-plane   14m   v1.25.2
worker1   Ready    <none>          11m   v1.25.2


vagrant@controller:~$ kubectl get pod -A
NAMESPACE     NAME                                       READY   STATUS    RESTARTS   AGE
kube-system   calico-kube-controllers-58dbc876ff-6mhs8   1/1     Running   0          2m16s
kube-system   calico-node-6dbf6                          1/1     Running   0          2m16s
kube-system   calico-node-kp4xw                          1/1     Running   0          2m16s
kube-system   coredns-565d847f94-kbc46                   1/1     Running   0          12m
kube-system   coredns-565d847f94-nhgb8                   1/1     Running   0          12m
kube-system   etcd-cplane1                               1/1     Running   0          12m
kube-system   kube-apiserver-cplane1                     1/1     Running   0          12m
kube-system   kube-controller-manager-cplane1            1/1     Running   0          12m
kube-system   kube-proxy-tjxn6                           1/1     Running   0          3m18s
kube-system   kube-proxy-xthvl                           1/1     Running   0          12m
kube-system   kube-scheduler-cplane1                     1/1     Running   0          12m

La commande vagrant push permet de lancer des actions après le provisionnement de la stack. Bien pratique dans mon cas puisque je veux parfois pouvoir valider que je suis capable de monter un cluster à la main.

Installation d’outils sur le node controller

J’adore asdf car il permet d’installer tous les outils permettant de gérer facilement des clusters kubernetes. Il est préinstallé sur le node controller.

Exemple installation de Helm :

Terminal window
ssh controller
pip install lastversion --user
git clone https://github.com/asdf-vm/asdf.git ~/.asdf --branch v$(lastversion asdf-vm/asdf)


asdf plugin add helm
asdf install helm latest
asdf global helm latest


vagrant@controller:~$ helm version
version.BuildInfo{Version:"v3.10.1", GitCommit:"9f88ccb6aee40b9a0535fcc7efea6055e1ef72c9", GitTreeState:"clean", GoVersion:"go1.18.7"}

Initialisation du cluster via un playbook

Vous êtes le maître de l’initialisation du cluster et vous voulez passer cette étape. J’ai écrit un simple playbook permettant de réaliser cette action. Pour le lancer rien de plus simple :

Terminal window
vagrant push

Avantages de vagrant

Les environnements provisionner peuvent être suspendus pour libérer les ressources temporairement. Cela permet de switcher de context et d’y revenir plus tard.

Les commandes à connaître sont : vagrant suspend et vagrant resume.

La suite

Je vais poursuivre ma formation et je complèterai le projet au fil de mes avancées. Mais si vous avez des suggestions vous pouvez créer des issues sur le projet : CKASandBox ↗