Loading search data...

Sandbox d’apprentissage certification kubernetes CKA

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/ubuntu2004" # Image for all installations
  kubectl_version = "1.23.1-00"
  kube_version = "1.22.5-00"
  docker_version = "5:19.03.15~3-0~ubuntu-focal"

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_rsa):

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

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

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.22.5
worker1   NotReady   <none>                 26s     v1.22.5

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
Warning: policy/v1beta1 PodDisruptionBudget is deprecated in v1.21+, unavailable in v1.25+; use policy/v1 PodDisruptionBudget
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
master1   Ready    control-plane,master   6m21s   v1.22.5
worker1   Ready    <none>                 4m16s   v1.22.5

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,master   74m   v1.23.1
worker1   Ready    <none>                 74m   v1.23.1
vagrant@controller:~$ kubectl get pod -A
NAMESPACE     NAME                                       READY   STATUS    RESTARTS   AGE
kube-system   calico-kube-controllers-85b5b5888d-6pfhk   1/1     Running   0          72m
kube-system   calico-node-g5m54                          1/1     Running   0          72m
kube-system   calico-node-x8wnw                          1/1     Running   0          72m
kube-system   coredns-64897985d-cxvlr                    1/1     Running   0          73m
kube-system   coredns-64897985d-hnb4m                    1/1     Running   0          73m
kube-system   etcd-master1                               1/1     Running   0          73m
kube-system   kube-apiserver-master1                     1/1     Running   0          73m
kube-system   kube-controller-manager-master1            1/1     Running   0          73m
kube-system   kube-proxy-2z7nt                           1/1     Running   0          73m
kube-system   kube-proxy-kwqb6                           1/1     Running   0          73m
kube-system   kube-scheduler-master1                     1/1     Running   0          73m
kube-system   metrics-server-6c49cf6978-pj267            1/1     Running   0          6m12s

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 arkade 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
vagrant@controller:~$ ark get helm

Downloading: helm
Downloading: https://get.helm.sh/helm-v3.5.2-linux-amd64.tar.gz
11.79 MiB / 11.79 MiB [-----------------------------------------------------------------------------------------------------------------------------------------] 100.00%
/tmp/helm-v3.5.2-linux-amd64.tar.gz written.
/tmp/linux-amd64 linux-amd64/
/tmp/helm linux-amd64/helm
/tmp/LICENSE linux-amd64/LICENSE
/tmp/README.md linux-amd64/README.md
2022/01/07 06:58:07 extracted tarball into /tmp: 3 files, 0 dirs (349.621674ms)
2022/01/07 06:58:07 Extracted: /tmp/helm
2022/01/07 06:58:07 Copying /tmp/helm to /home/vagrant/.arkade/bin/helm

Tool written to: /home/vagrant/.arkade/bin/helm

# Add arkade binary directory to your PATH variable
export PATH=$PATH:$HOME/.arkade/bin/

# Test the binary:
/home/vagrant/.arkade/bin/helm

# Or install with:
sudo mv /home/vagrant/.arkade/bin/helm /usr/local/bin/

vagrant@controller:~$ helm version
WARNING: Kubernetes configuration file is group-readable. This is insecure. Location: /home/vagrant/.kube/config
WARNING: Kubernetes configuration file is world-readable. This is insecure. Location: /home/vagrant/.kube/config
version.BuildInfo{Version:"v3.5.2", GitCommit:"167aac70832d3a384f65f9745335e9fb40169dc2", GitTreeState:"dirty", GoVersion:"go1.15.7"}

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 a fait de nouveaux je complèterai le projet. Mais si vous avez des suggestions vous pouvez créer des issues sur le projet : CKASandBox

Mots clés :

devops tutorials kubernetes ansible vagrant

Autres Articles



Si vous avez apprécié cet article de blog, vous pouvez m'encourager à produire plus de contenu en m'offrant un café sur Ko-Fi. Vous pouvez aussi passer votre prochaine commande sur amazon, sans que cela ne nous coûte plus cher, via ce lien. Je vous remercie de votre soutien


Commentaires: