Passer les certifications 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 :
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 :
10.240.0.10 controller
Ensuite on se connecte en ssh (en utilisant la clé id_ed25519):
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:
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 :
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 :
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 :
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 :
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.
vagrant push
....
Dans une autre session :
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 :
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 :
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