Ce guide détaille les étapes pour installer un cluster Kubernetes multi-nœuds en utilisant l'outil kubeadm. kubeadm simplifie le processus de bootstrapping d'un cluster en respectant les bonnes pratiques.
Nous allons configurer un cluster avec un nœud Control Plane et deux Worker Nodes sur Ubuntu. Nous utiliserons containerd comme Container Runtime Interface (CRI).
Architecture cible :
k8s-control)k8s-worker1, k8s-worker2)Ces étapes doivent être exécutées sur toutes les machines (Control Plane et Workers).
Assurez-vous que chaque machine a un hostname unique. Changez-le si nécessaire et reconnectez-vous.
# Sur le Control Plane
sudo hostnamectl set-hostname k8s-control
# Sur le premier Worker
sudo hostnamectl set-hostname k8s-worker1
# Sur le deuxième Worker
sudo hostnamectl set-hostname k8s-worker2
/etc/hosts (Optionnel mais recommandé)Pour assurer une résolution de nom cohérente entre les nœuds au sein du cluster, ajoutez les IPs privées et hostnames de tous les nœuds dans /etc/hosts sur chaque machine.
# Exemple (adaptez avec vos IPs)
sudo vim /etc/hosts
# Ajoutez les lignes suivantes :
172.31.28.195 k8s-control
172.31.24.234 k8s-worker1
172.31.31.176 k8s-worker2
Les modules overlay (pour le système de fichiers overlay utilisé par les conteneurs) et br_netfilter (pour que le pont réseau voie le trafic iptables) sont nécessaires.
# Créer le fichier de configuration pour charger les modules au démarrage
cat << EOF | sudo tee /etc/modules-load.d/k8s.conf
overlay
br_netfilter
EOF
# Charger les modules immédiatement
sudo modprobe overlay
sudo modprobe br_netfilter
Ces paramètres sont requis pour permettre à iptables de voir le trafic passer et pour activer le transfert IP, essentiels pour la mise en réseau des pods.
# Créer le fichier de configuration sysctl
cat <<EOF | sudo tee /etc/sysctl.d/99-kubernetes-cri.conf
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1
net.bridge.bridge-nf-call-ip6tables = 1
EOF
# Appliquer les changements sysctl sans redémarrage
sudo sysctl --system
containerd (Container Runtime)Kubernetes a besoin d'un runtime de conteneurs pour exécuter les Pods.
# Installation de containerd
sudo apt-get update
sudo apt-get install -y containerd
# Créer le répertoire de configuration s'il n'existe pas
sudo mkdir -p /etc/containerd
# Générer la configuration par défaut de containerd
# Important : vérifiez si le cgroup driver doit être mis à 'systemd'
# sudo containerd config default | sudo tee /etc/containerd/config.toml
# Dans la section [plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runc.options]
# SystemdCgroup = true
sudo containerd config default | sudo tee /etc/containerd/config.toml
# Redémarrer containerd pour appliquer la configuration
sudo systemctl restart containerd
sudo systemctl enable containerd # S'assurer qu'il démarre au boot
Note : Assurez-vous que le SystemdCgroup est configuré à true dans /etc/containerd/config.toml. kubeadm détecte généralement le cgroup driver, mais il est bon de s'en assurer, car kubelet et containerd doivent utiliser le même.
Le kubelet requiert que le swap soit désactivé pour fonctionner correctement.
# Désactiver le swap immédiatement
sudo swapoff -a
# Commenter la ligne du swap dans /etc/fstab pour désactiver au redémarrage
sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab
Ces paquets sont nécessaires sur tous les nœuds :
kubeadm: L'outil pour initialiser le cluster.kubelet: L'agent qui s'exécute sur chaque nœud et gère les conteneurs.kubectl: L'outil en ligne de commande pour interagir avec le cluster.# Mise à jour et installation des dépendances
sudo apt-get update
sudo apt-get install -y apt-transport-https ca-certificates curl gpg
# Ajout de la clé GPG pour les dépôts Kubernetes
# Adaptez si la structure change sur packages.k8s.io
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.32/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
# Ajout du dépôt apt Kubernetes
echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.32/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list
# Installation des outils Kubernetes à la version CKA cible
sudo apt-get update
sudo apt-get install -y kubelet=1.32.1-1.1 kubeadm=1.32.1-1.1 kubectl=1.32.1-1.1
# Bloquer les versions pour éviter les mises à jour automatiques accidentelles
sudo apt-mark hold kubelet kubeadm kubectl
Cette étape initialise le cluster Kubernetes sur le nœud désigné comme Control Plane.
# Exécutez cette commande UNIQUEMENT sur k8s-control
# --pod-network-cidr est requis par certains CNI comme Calico.
# Assurez-vous que ce CIDR ne chevauche pas d'autres réseaux.
# --kubernetes-version spécifie la version à utiliser.
sudo kubeadm init --pod-network-cidr=192.168.0.0/16 --kubernetes-version=1.32.1
L'exécution de kubeadm init prendra quelques minutes. Si elle réussit, elle affichera :
kubectl pour l'utilisateur courant.kubeadm join avec un token et un hash de certificat CA, à exécuter sur les Worker Nodes pour les joindre au cluster.Configurez kubectl sur le Control Plane :
# Crée le répertoire de configuration kubectl
mkdir -p $HOME/.kube
# Copie la configuration admin du cluster dans le répertoire utilisateur
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
# Définit les permissions correctes pour l'utilisateur courant
sudo chown $(id -u):$(id -g) $HOME/.kube/config
Vérifiez l'état initial du nœud Control Plane :
kubectl get nodes
# Le statut sera 'NotReady' car aucun CNI n'est encore installé
NAME STATUS ROLES AGE VERSION
k8s-control NotReady control-plane,master 2m21s v1.32.1
Un plugin CNI (Container Network Interface) est nécessaire pour que les Pods puissent communiquer entre eux à travers les nœuds. Nous utiliserons Calico.
# Appliquer le manifeste Calico (assurez-vous que l'URL est à jour si nécessaire)
kubectl apply -f https://docs.projectcalico.org/manifests/calico.yaml
Après quelques instants, le statut du nœud k8s-control devrait passer à Ready.
kubectl get nodes
NAME STATUS ROLES AGE VERSION
k8s-control Ready control-plane,master 5m v1.32.1
Utilisez la commande kubeadm join affichée à la fin de kubeadm init pour joindre chaque Worker Node au cluster.
Si vous avez perdu la commande join :
Vous pouvez générer un nouveau token et afficher la commande join sur le Control Plane :
# Sur k8s-control
kubeadm token create --print-join-command
Exécutez la commande join sur chaque Worker Node (k8s-worker1, k8s-worker2) :
# Exemple de commande (UTILISEZ CELLE GÉNÉRÉE PAR VOTRE `kubeadm init` ou `token create`)
sudo kubeadm join <control-plane-ip>:6443 --token <token> --discovery-token-ca-cert-hash sha256:<hash>
# Exemple concret (NE PAS COPIER/COLLER TEL QUEL) :
# sudo kubeadm join 172.31.28.195:6443 --token t6zdej.abcdefghijklmnop --discovery-token-ca-cert-hash sha256:1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef
Après avoir joint les workers, vérifiez que tous les nœuds sont présents et Ready.
kubectl get nodes
# Le résultat devrait ressembler à ceci :
NAME STATUS ROLES AGE VERSION
k8s-control Ready control-plane,master 10m v1.32.1
k8s-worker1 Ready <none> 2m v1.32.1
k8s-worker2 Ready <none> 1m55s v1.32.1
Félicitations ! Votre cluster Kubernetes est maintenant opérationnel.