Temps de lecture estimé: 9 minutes
Je suis en train de faire évoluer la manière dont je gère mes environnements de développement et de prod.
J’ai actuellement un Hyperviseur Vmware Esxi qui fait tourner une machine virtuelle Linux (Ubuntu). C’est mon serveur principal et tous mes services, applications et site web sont sur ce même serveur de façon un peu monolithique.
MySql, apache, PostgreSQL, mon instance Gitlab, mon site CV, ce blog WordPress quelques autres services tournent sur le même serveur, côte à côte, et non dissociés.
J’ai envie de scinder tout ça et au passage de faire joujou d’améliorer la façon dont je déploie mes projets en y ajoutant un peu d’intégration et de développement continu (CI/CD) avec Gitlab, de la conteneurisation Docker et … pourquoi pas de l’orchestration et du clustering Kubernetes!!
L’orchestration et le clustering étant à la base de cette pile, je te propose aujourd’hui la première brique, comment installer un cluster Kubernetes sur Ubuntu 22.04 fraichement installé.
De mon côté, le cluster sera physiquement sur une seule machine. Pas trop davantage d’avoir un cluster…. Si la machine tombe, le cluster tombe!! Mais bon ça permet de tester (et ça permet d’avoir l’architecture déjà en place donc le jour où j’ai envie de scaler, ça sera “plus simple”).
Donc après avoir fait 2 nouvelles machines virtuelles avec une installation fraiche de la dernière version Ubuntu LTS, la 22.04 Jammy Jellyfish sur chacune des VMs, place à Kubernetes. La plupart des étapes suivantes sont à faire sur les 2 machines. Il n’y aura que la déclaration du master d’un côté et la demande de rejoindre le cluster sur le worker de l’autre côté qui seront à faire en fonction des machines.
prérequis système et Vérification des ports
Avant de se lancer dans l’installation de Kubernetes, il y a quelques prérequis à vérifier.
Réseaux pontés
Déjà, il faut s’assurer que le système peut avoir des réseaux bridge. Pour ça il faut vérifier que le noyau Linux a bien le module br_netfilter chargé.
Un petit
lsmod | grep br_netfilter
Ça permet de vérifier. s’il n’y a pas de résultat, il faut alors l’activer avec
sudo modprobe br_netfilter
Je vérifie ensuite que le firewall Iptables peut voir ce trafic bridgé
sysctl net.bridge.bridge-nf-call-iptables
Si ce n’est pas le cas, je vais créer un fichier /etc/sysctl.d/k8s.conf pour charger les bons paramètres au démarrage
cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
EOF
Et je l’applique directement
sudo sysctl --system
Désactiver le swap
Pour faire fonctionner Kubernetes (kubelet), il faut désactiver le swap. Pour le faire immédiatement
sudo swapoff -a
Maintenant pour le désactiver au démarrage, il faut éditer le fichier des partitions /etc/fstab donc
sudo nano /etc/fstab
Pour commenter la ligne de swap. Dans mon cas
#/swap.img none swap sw 0 0
Vérifier les ports par défaut
Une petite vérification pour savoir si tous les ports par défaut listés ne sont pas utilisés par d’autres applications
sudo netstat -lnp | grep 6443
Dans mon cas, j’ai eu la bonne idée d’installer MicroK8s par défaut sur une des VM. du coup des ports étaient utilisés. Pour repartir sans microK8s
microk8s.disable dashboard dns
sudo snap remove microk8s
définir les noms d’hôtes
Je vais avoir besoin, minimum, d’un nœud Master et d’un nœud Worker. Donc sur chaque machine je définis son petit hostname
#sur la machine virtuelle Master
sudo hostnamectl k8s-master.anthony-jacob.com
#sur la machine virtuelle Worker
sudo hostnamectl k8s-worker.anthony-jacob.com
Sur chaque machine j’ai aussi édité le fichier /etc/hosts en fonction de la machine
sudo nano /etc/hosts
127.0.0.1 localhost
127.0.1.1 k8s-workernode k8s-workernode.anthony-jacob.com
#IP Master
192.168.8.89 k8s-masternode k8s-masternode.anthony-jacob.com</p>
#IP Worker
192.168.8.88 k8s-workernode k8s-workernode.anthony-jacob.com
Installation du container runtime – Docker.
Kubernetes peut utiliser différents environnements de conteneurisation. Dans mon cas je souhaite utiliser Docker.
Depuis la version 1.24 de Kubernetes, l’intégration de Docker via dockershim n’est plus disponible. Il faut maintenant passer par cri-dockerd. Dans le cas d’une mise à jour, il y a toute une procédure disponible. Dans mon cas, c’est une installation from scratch donc pas de problème de migration (juste des problèmes d’installations !!! )
Installation de Docker
Avant d’installer l’interface cri-dockerd qui fera le lien entre Kubernetes et Docker, il faut avant tout installer Docker.
Je commence par ajouter la clé GPG du dépôt Docker. Les clés ne s’ajoutent plus avec apt-key, qui est déprécié. Il faut maintenant gérer les clés manuellement dans /etc/apt/trusted.gpg.d/ . Donc je la télécharge la clé
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/trusted.gpg.d/docker.gpg
Et j’ajoute le dépôt dans la liste des sources d’apt
echo \
"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/trusted.gpg.d/docker.gpg] https://download.docker.com/linux/ubuntu \
$(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
Je peux maintenant mettre à jour les dépôts disponibles et installer Docker
sudo apt-get update && sudo apt-get install docker-ce docker-ce-cli containerd.io docker-compose-plugin
Utiliser systemd
Pour la gestion des droits de Kubernetes, il est conseillé d’utiliser systemd au lieu de cgroupfs . Par conséquent, Docker aussi devrait utiliser systemd. Pour le vérifier
docker info
Devrait donner
Cgroup Driver: systemd
Cgroup Version: 2
Si ce n’est pas le cas, il faut spécifier des paramètres au lancement du daemon Docker.
Pour ça il faut créer (ou éditer si déjà présent) le fichier /etc/docker/daemon.json , donc
nano /etc/docker/daemon.json
Pour y mettre les options d’exécutions
{
"exec-opts": ["native.cgroupdriver=systemd"]
}
Un petit reload de tout ça
sudo systemctl daemon-reload
sudo systemctl reload docker
et voilà, je vérifie que le service tourne
systemctl status docker
Ajout de mon utilisateur au groupe docker
Au passage j’en profite pour rajouter mon utilisateur au groupe docker
sudo usermod -aG docker $USER
newgrp docker
Installation de Mirantis Cri-Dockerd
Pour installer Cri-dockerd, l’interface entre Kubernetes et Docker, il faut Go.
wget https://storage.googleapis.com/golang/getgo/installer_linux
chmod +x ./installer_linux
./installer_linux
source ~/.bash_profile
Si tout est OK, go est installé
go version
devrait donner
go version go1.18.3 linux/amd64
Ensuite dans un répertoire de travail, je clone le repository git,
je compile cri-dockerd,
je le copie dans les bons répertoires,
j’installe et j’active les services
git clone https://github.com/Mirantis/cri-dockerd.git
cd cri-dockerd
mkdir bin
go get && go build -o bin/cri-dockerd
mkdir -p /usr/local/bin
sudo install -o root -g root -m 0755 bin/cri-dockerd /usr/local/bin/cri-dockerd
sudo cp -a packaging/systemd/* /etc/systemd/system
sudo sed -i -e 's,/usr/bin/cri-dockerd,/usr/local/bin/cri-dockerd,' /etc/systemd/system/cri-docker.service
sudo systemctl daemon-reload
sudo systemctl enable cri-docker.service
sudo systemctl enable --now cri-docker.socket
systemctl status cri-docker.socket
Installation de Kubernetes
Maintenant que les prérequis à Kubernetes sont là, je vais pouvoir passer à l’installation de Kubernetes. Je télécharge la clé gpg du dépôt
curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo gpg --dearmor -o /etc/apt/trusted.gpg.d/google-k8s.gpg
Et j’ajoute Kubernetes à la liste des dépôts en créant le fichier /etc/apt/sources.list.d/k8s.list
sudo nano /etc/apt/sources.list.d/k8s.list
j’y met le dépôt en spécifiant la clé
deb [arch=amd64 signed-by=/etc/apt/trusted.gpg.d/google-k8s.gpg] http://apt.kubernetes.io/ kubernetes-xenial main
# deb-src http://apt.kubernetes.io/ kubernetes-xenial main
Je peux maintenant mettre à jour les dépôts disponibles et installer Kubernetes
sudo apt update && sudo apt install kubeadm kubelet kubectl kubernetes-cni
Configuration et déclaration du Master Kubernetes
Toutes les étapes précédentes étaient à faire sur les 2 VMs, la machine qui sera le master et la machine qui sera le worker du cluster Kubernetes. Ici, j’initialise le master.
l’adresse IP du master est 192.168.8.89
j’utilise docker au travers de cri-dockerd.
systemctl status cri-docker.socket
Me permet de voir que le socket d’écoute est unix:///run/cri-dockerd.sock
Et je vais devoir par la suite devoir installer un pod réseaux. Dans mon cas je choisirais Flannel, par défaut Flannel utilisera adressage CIDR 10.244.0.0/16 pour les pods
Avec toutes ces informations, je peux lancer la commande
sudo kubeadm init \
--pod-network-cidr=10.244.0.0/16 \
--cri-socket=unix:///run/cri-dockerd.sock \
--apiserver-advertise-address=192.168.8.89
Si tout se passe comme prévu, kubeadm devrait arriver à la fin de la configuration et indiquer quelque chose comme
Your Kubernetes control-plane has initialized successfully!
To start using your cluster, you need to run the following as a regular user:
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config
You should now deploy a Pod network to the cluster.
Run "kubectl apply -f [podnetwork].yaml" with e of the options listed at:
/docs/concepts/cluster-administration/addons/
You can now join any number of machines by running the following on each node
as root:
kubeadm join <control-plane-host>:<control-plane-port> --token <token> --discovery-token-ca-cert-hash sha256:<hash>
Il faut mettre de côté la commande
kubeadm join <control-plane-host>:<control-plane-port> --token <token> --discovery-token-ca-cert-hash sha256:<hash>
qui nous servira pour le worker
Mis à par ça, comme conseillé je copie les préférences dans mon dossier personnel
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config
Installation du pod Réseau
Comme annoncé plus haut, je déploie un pod réseau.
kubectl apply -f https://raw.githubusercontent.com/flannel-io/flannel/master/Documentation/kube-flannel.yml
Quelques secondes après, je lance
kubectl get pods -n kube-system
Pour vérifier que tous mes pods de base (Flannel inclus) sont lancés
NAME READY STATUS RESTARTS AGE
coredns-6d4b75cb6d-rn2cv 1/1 Running 3(4d7h ago) 4d8h
coredns-6d4b75cb6d-zkftf 1/1 Running 3(4d7h ago) 4d8h
etcd-k8s-masternode.anthony-jacob.com 1/1 Running 3(4d7h ago) 4d8h
kube-apiserver-k8s-masternode.anthony-jacob.com 1/1 Running 3(4d7h ago) 4d8h
kube-controller-manager-k8s-masternode.anthony-jacob.com 1/1 Running 4(4d7h ago) 4d8h
kube-flannel-ds-hntr4 1/1 Running 0 4d7h
kube-flannel-ds-s8n5h 1/1 Running 3(4d7h ago) 4d8h
kube-proxy-fmzl2 1/1 Running 3(4d7h ago) 4d8h
kube-proxy-zrb4p 1/1 Running 0 4d7h
kube-scheduler-k8s-masternode.anthony-jacob.com 1/1 Running 5(4d7h ago) 4d8h
Optionnellement, pour isoler le control plane pour un cluster Kubernetes mono-machine pour le développement, exécutez:
kubectl taint nodes --all node-role.kubernetes.io/master-
Déclarer le Worker et rejoindre le master
Depuis la machine worker maintenant, je vais rejoindre le cluster et déclarer la machine au master avec la commande que m’a précédemment donnée l’initialisation du master
kubeadm join <control-plane-host>:<control-plane-port> --token <token> --discovery-token-ca-cert-hash sha256:<hash>
Il est possible de régénérer cette commande, depuis le master, avec
kubeadm token create --print-join-command
ça donnera tout ce qu’il faut
kubeadm join 192.168.8.88:6443 --token fepq6o.am5wzzq75utqzzyy --discovery-token-ca-cert-hash sha256:c9f7798ed7a6ccf03b5590cddedecb3e250ea9427103e22ed10b30e3b43a2cfc --cri-socket=unix:///run/cri-dockerd.sock
Je vérifie que tout est bon
kubectl get nodes -A -o wide
NAME STATUS ROLES AGE VERSION INTERNAL-IP EXTERNAL-IP OS-IMAGE KERNEL-VERSION CONTAINER-RUNTIME
k8s-masternode.anthony-jacob.com Ready control-plane 4d9h v1.24.1 192.168.8.89 <none> Ubuntu 22.04 LTS 5.15.0-37-generic docker://20.10.17
k8s-workernode.anthony-jacob.com Ready <none> 4d7h v1.24.1 192.168.8.88 <none> Ubuntu 22.04 LTS 5.15.0-37-generic docker://20.10.17
Autocomplétion
Le panel de commande de Kubernetes à l’air sssuuuuper large, donc pour aller plus loin j’ai aussi mis en place l’autocomplétion sur le système. Donc si ce n’est pas déjà fait
apt-get install bash-completion
Et ensuite
kubectl completion bash | sudo tee /etc/bash_completion.d/kubectl > /dev/null
Installer Helm Gestionnaire de paquet Kubernetes
Par la suite je pourrai avoir besoin de helm, le gestionnaire de paquet Kubernetes. Assez simple, on ajoute la bonne clé, le dépôt dans la liste des sources et il suffit de l’installer avec apt
curl https://baltocdn.com/helm/signing.asc | gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/helm.gpg > /dev/null
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/trusted.gpg.d/helm.gpg] https://baltocdn.com/helm/stable/debian/ all main" | sudo tee /etc/apt/sources.list.d/helm-stable-debian.list
sudo apt-get update
sudo apt-get install helm
Voilà, l’installation sommaire d’un cluster Kubernetes est faite de mon côté. Je n’ai plus qu’à approfondir son utilisation.
J’ai fait 2 autres articles sur l’installation d’interfaces pour gérer le cluster ou au moins avoir les informations essentielles. un article pour installer Kubernetes Dashboard et un autre pour installer Portainer.io
Dis moi ce que tu en penses et si ça a pu te servir ! En attendant, je te dis à bientôt pour de nouvelles aventures!!