Introduction
La configuration d’un cluster Kubernetes chez soi est un excellent moyen d’acquérir une expérience pratique avec l’orchestration de conteneurs. Que vous vous prépariez à des certifications comme la CKA (Certified Kubernetes Administrator), que vous expérimentiez des applications cloud-native ou que vous construisiez un environnement de développement, ce guide vous aidera à mettre en place un cluster Kubernetes fonctionnel sur Ubuntu Server 24.04.
Ce tutoriel couvre la configuration d’un cluster à plusieurs nœuds avec un nœud de contrôle (control plane) et deux nœuds workers (travailleurs) en utilisant des outils comme kubeadm, containerd et Calico pour le réseau.
Architecture du cluster
Nous allons configurer un cluster avec trois machines virtuelles :
| Rôle | Nom d’hôte | Adresse IP |
|---|---|---|
| Nœud de contrôle | k8s-master | 192.168.1.100 |
| Nœud worker 1 | k8s-worker1 | 192.168.1.101 |
| Nœud worker 2 | k8s-worker2 | 192.168.1.102 |
Tous les nœuds exécutent Ubuntu Server 24.04 LTS.
Conditions préalables
Avant de commencer, assurez-vous d’avoir les éléments suivants :
- Au moins deux machines (ou VM) exécutant Ubuntu Server 24.04.
- Accès root ou des privilèges sudo sur toutes les machines.
- Connectivité réseau entre les nœuds.
- Chaque machine doit avoir au moins 2 Go de RAM et 2 cœurs CPU (plus pour des charges de travail plus lourdes).
Étape 1 : Mise à jour des paquets système et installation des dépendances
Sur tous les nœuds, mettez à jour les listes de paquets et installez les dépendances nécessaires :
bash
sudo apt update && sudo apt upgrade -y
sudo apt install -y apt-transport-https ca-certificates curl gnupg lsb-releaseÉtape 2 : Désactivation du swap
Kubernetes exige que le swap soit désactivé sur tous les nœuds :
bash
sudo swapoff -a
sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstabÉtape 3 : Chargement des modules du noyau et configuration des paramètres sysctl
Chargez les modules du noyau requis et configurez les paramètres sysctl :
bash
cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
overlay
br_netfilter
EOF
sudo modprobe overlay
sudo modprobe br_netfilter
cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-iptables = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.ipv4.ip_forward = 1
EOF
sudo sysctl --systemÉtape 4 : Installation de containerd comme runtime de conteneurs
Sur tous les nœuds, installez containerd :
bash
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null sudo apt update sudo apt install -y containerd.io
Configurez containerd pour utiliser systemd comme cgroup :
bash
sudo mkdir -p /etc/containerd
containerd config default | sudo tee /etc/containerd/config.toml
sudo sed -i 's/SystemdCgroup = false/SystemdCgroup = true/' /etc/containerd/config.toml
sudo systemctl restart containerd
sudo systemctl enable containerdÉtape 5 : Installation de kubeadm, kubelet et kubectl
Sur tous les nœuds, ajoutez le dépôt Kubernetes et installez les outils :
bash
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.30/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes.gpg
echo "deb [signed-by=/etc/apt/keyrings/kubernetes.gpg] https://pkgs.k8s.io/core:/stable:/v1.30/deb/ /" | sudo tee /etc/apt/sources.list.d/kubernetes.list
sudo apt update
sudo apt install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectlÉtape 6 : Initialisation du nœud de contrôle
Sur le nœud k8s-master, initialisez le cluster :
bash
sudo kubeadm init --pod-network-cidr=192.168.0.0/16 --apiserver-advertise-address=192.168.1.100Une fois terminé, configurez votre fichier kubeconfig :
bash
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/configEnregistrez la commande kubeadm join affichée à la fin de la sortie — elle sera utilisée pour ajouter les nœuds workers.
Étape 7 : Installation d’une interface réseau (CNI) — Calico
Installez Calico pour permettre la communication entre les pods :
bash
kubectl apply -f https://raw.githubusercontent.com/projectcalico/calico/v3.26/manifests/calico.yamlVérifiez que les pods Calico sont en cours d’exécution :
bash
kubectl get pods -n kube-systemÉtape 8 : Rejoindre les nœuds workers au cluster
Sur chaque nœud worker, exécutez la commande kubeadm join que vous avez enregistrée précédemment. Elle devrait ressembler à ceci :
bash
sudo kubeadm join 192.168.1.100:6443 --token <votre-token> --discovery-token-ca-cert-hash sha256:<votre-hash>Étape 9 : Vérification du cluster
Retournez sur le nœud de contrôle et vérifiez que tous les nœuds sont en ligne :
bash
kubectl get nodesVous devriez voir les trois nœuds avec le statut Ready.
Étape 10 : Test du cluster avec un déploiement exemple
Déployez une application simple pour tester le cluster :
bash
kubectl create deployment nginx --image=nginx
kubectl expose deployment nginx --port=80 --type=NodePort
kubectl get pods,svcAccédez à l’application via l’IP d’un nœud worker et le port NodePort.
Dépannage
- Nœud bloqué sur NotReady : Vérifiez que le CNI est correctement installé.
- Erreur de token expiré : Générez un nouveau token avec
kubeadm token create --print-join-command. - Problèmes de résolution DNS : Assurez-vous que CoreDNS est en cours d’exécution (
kubectl get pods -n kube-system).
Conclusion
Vous avez maintenant un cluster Kubernetes opérationnel chez vous sur Ubuntu Server 24.04. Cette configuration est idéale pour l’apprentissage, le développement et les tests. Vous pouvez maintenant commencer à déployer des applications, expérimenter avec les fonctionnalités de Kubernetes et approfondir vos compétences.
Bon déploiement ! 🚀
