Ce tutoriel détaille l'installation pas à pas d'un cluster Kubernetes multi-nœuds (1 Master, 2 Workers) dans l'environnement du miniLab.
En utilisant les standards actuels (Kubeadm, Containerd et Flannel), nous couvrirons toutes les étapes essentielles : de la préparation système et l'initialisation du Control Plane, jusqu'à la jonction des nœuds et la configuration de l'administration distante. Un guide pratique pour obtenir rapidement un environnement DevOps fonctionnel.
Architecture cible :
- 1 Nœud Maître (Control Plane) : k8s-master (minimum 2 cpu)
- 2 Nœuds Travailleurs (Workers) : k8s-worker1, k8s-worker2
A partir du Contexte miniLab (192.168.1.0/24)
192.168.1.10: k8s-master192.168.1.11: k8s-worker1192.168.1.12: k8s-worker2
Et une GUI dans le réseau pour administrer l'ensemble en SSH.
¶ Préparation
Les opérations suivantes sont à réaliser sur chaque noeud du cluster.
- Configuration des noms d'hôtes :
- modification du hostname
nano /etc/hostname- On n'oublie pas de modifier aussi la résolution locale de la machine avec l'adresse
127.0.1.1en ajoutant aussi la résolution des IP du cluster :
Ce qui donne par exemple pour le master :nano /etc/hosts127.0.0.1 localhost 127.0.1.1 k8s-master 192.168.1.10 k8s-master 192.168.1.11 k8s-worker1 192.168.1.12 k8s-worker2 ...
Assurez-vous que chaque machine a un nom unique.
- Désactiver le swap :
sudo swapoff -a
sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab
# il faut aussi empêcher systemd de l'activer automatiquement :
sudo systemctl mask swap.target
- Activer le routage :
# Modifie la configuration pour sysctl
cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.ipv4.ip_forward = 1
EOF
# Applique la modification immédiatement
sudo sysctl --system
- Charger les modules du noyau nécessaires pour la gestion réseau des conteneurs :
cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
overlay
br_netfilter
EOF
sudo modprobe overlay
sudo modprobe br_netfilter
¶ Installer le Runtime
Kubernetes a besoin d'un runtime pour lancer les conteneurs. Nous utiliserons Containerd (le standard actuel).
Les opérations suivantes sont à réaliser sur chaque noeud du cluster.
¶ 1. Installer containerd
sudo apt-get update
sudo apt-get install -y containerd
Note : Si le paquet n'est pas trouvé (ce qui est rare sur Debian récent), il faudra ajouter le repo officiel de Docker, mais celui de Debian suffit généralement.
¶ 2. Configurer containerd pour utiliser Systemd
sudo mkdir -p /etc/containerd
sudo containerd config default | sudo tee /etc/containerd/config.toml
# On modifie la config pour activer SystemdCgroup
sudo sed -i 's/SystemdCgroup = false/SystemdCgroup = true/g' /etc/containerd/config.toml
# On met à jour l'image sandbox (pause) pour kubeadm 1.33+
sudo sed -i 's/sandbox_image = "registry.k8s.io\/pause:3.8"/sandbox_image = "registry.k8s.io\/pause:3.10"/g' /etc/containerd/config.toml
sudo systemctl restart containerd
¶ Installer Kubeadm, Kubelet et Kubectl
¶ Installation des dépôts
Nous allons utiliser les dépôts officiels Kubernetes (pkgs.k8s.io)
Voir : https://kubernetes.io/fr/docs/tasks/tools/install-kubectl/
sudo apt-get install -y apt-transport-https ca-certificates curl gnupg
sudo mkdir -p -m 755 /etc/apt/keyrings
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.33/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
sudo chmod 644 /etc/apt/keyrings/kubernetes-apt-keyring.gpg
echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.33/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list
sudo chmod 644 /etc/apt/sources.list.d/kubernetes.list
¶ Installation des binaires
sudo apt-get update
sudo apt-get install -y kubelet kubeadm kubectl containernetworking-plugins
# verrouillage de version
sudo apt-mark hold kubelet kubeadm kubectl
¶ Initialiser le Cluster
Ne faites ceci que sur
k8s-master.
Nous spécifions --pod-network-cidr car nous utiliserons le plugin réseau Flannel :
sudo kubeadm init --pod-network-cidr=10.244.0.0/16
Cette commande peut prendre quelques minutes. À la fin, elle affichera une ligne commençant par
kubeadm join...Copiez cette ligne et gardez-la précieusement !
Configurez votre accès utilisateur :
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 réseau Flannel
A faire sur
k8s-masteruniquement
Appliquez le manifeste officiel de Flannel. Comme nous avons utilisé le CIDR par défaut 10.244.0.0/16, il n'y a rien à modifier.
kubectl apply -f https://github.com/flannel-io/flannel/releases/latest/download/kube-flannel.yml
¶ Jonction des Workers
A faire sur
k8s-worker1etk8s-worker2
Collez la commande de jonction que vous avez récupérée plus haut, par exemple :
sudo kubeadm join 192.168.1.10:6443 --token f5q5d0.x53wzaj5inyd5g06 \
--discovery-token-ca-cert-hash sha256:626ebe3a392fa7726e78e069c6861b17eaea9a370bd7f1c23073102df9ec565e
¶ Vérification Finale
Retournez sur le Master et surveillez l'état du cluster :
kubectl get nodes
Attendez quelques instants. Vous devriez voir les statuts passer de NotReady à Ready.
Pour vérifier que Flannel fait bien son travail (c'est-à-dire qu'il attribue bien des IPs aux pods système), lancez :
kubectl get pods -A
Vérifiez que les pods coredns (qui gèrent le DNS interne) sont bien Running. Ils attendent souvent que le réseau soit prêt pour démarrer.
Vérifiez que les pods kube-flannel sont Running sur chaque nœud.
Une fois que tous les nœuds sont Ready, votre cluster de base est fonctionnel.
¶ debug coredns hs
En cas de problème avec les pods coredns, regardez le log d'un des pods coredns, par exemple :
kubectl describe pod -n kube-system coredns-xxxxxxxxxx-xxxx
Si ce message est visible : failed to find plugin "flannel" in path [/usr/lib/cni]
- vérifiez que
flannelest bien dans/opt/cni/bin/:ls /opt/cni/bin/ - appliquez ceci sur chaque noeud du cluster (master et workers) :
sudo mkdir -p /usr/lib/cni sudo cp -r /opt/cni/bin/* /usr/lib/cni/ - sur le master, détruisez les pods coredns :
kubectl delete pod -n kube-system -l k8s-app=kube-dns - puis vérifiez que ça remonte :
kubectl get pods -n kube-system -w
¶ Gestion du cluster depuis le poste GUI
Pour ne pas travailler directement sur le cluster (et notamment le master), on ajoute les outils nécessaires sur le poste GUI, en y ajoutant la configuration pour gérer le cluster.
¶ Installation & configuration
Sur la machine GUI donc, on installe l'outil kubectl :
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
chmod +x kubectl
sudo mv kubectl /usr/local/bin/
Puis on récupère la configuration depuis le master :
mkdir -p ~/.kube
# Remplacez 'pascal' par le bon login
scp pascal@192.168.1.10:~/.kube/config ~/.kube/config
sudo chown $(id -u):$(id -g) ~/.kube/config
Vérifiez dans le fichier de configuration que l'IP est bien 192.168.1.10 et non 127.0.0.1 :
cat ~/.kube/config
ici ligne 5 :
apiVersion: v1
clusters:
- cluster:
certificate-authority-data: LS0tL[...]tLS0K
server: https://192.168.1.10:6443
name: kubernetes
contexts:
- context:
cluster: kubernetes
user: kubernetes-admin
name: kubernetes-admin@kubernetes
current-context: kubernetes-admin@kubernetes
kind: Config
preferences: {}
users:
- name: kubernetes-admin
user:
client-certificate-data: LS0tL[...]LS0tLS0K
client-key-data: LS0tLS1CRUdJT[...]WS0tLS0tCg==
Enfin, on installe l'autocomplétion propre à kubectl :
sudo apt-get install -y bash-completion
echo 'source <(kubectl completion bash)' >>~/.bashrc
# Prise en compte immédiate :
source ~/.bashrc
Dans le monde de Kubernetes, taper kubectl des dizaines de fois par jour devient vite fatiguant. La norme officieuse est de créer l'alias k. Voici comment créer cet alias et s'assurer que l'autocomplétion fonctionne aussi avec la lettre k :
echo 'alias k=kubectl' >>~/.bashrc
echo 'complete -o default -F __start_kubectl k' >>~/.bashrc
source ~/.bashrc
Ainsi, vous pouvez simplement taper k get pods ou utiliser k <TAB><TAB> pour explorer toutes les commandes disponibles.
¶ Vérification
Désormais, depuis la GUI, vous pouvez vérifier l'état du cluster :
k get nodes
Ainsi que l'état des pods système :
k get pods -A
