Installer Kubernetes avec kubeadm sur Linux en 2026

Étapes à suivre5

1. 1

   Préparer le système Linux (swap, modules, sysctl)

   Kubernetes exige que le swap soit désactivé — c’est une condition bloquante pour kubeadm init. Commencez par désactiver le swap immédiatement et empêchez son montage au prochain redémarrage :

   sudo swapoff -a
   sudo sed -i '/ swap / s/^/#/' /etc/fstab

   Vérifiez que le swap est bien à zéro avec free -h — la colonne Swap doit afficher 0B.

   Chargez les modules noyau requis par les conteneurs réseau (overlay pour les filesystems imbriqués, br_netfilter pour le routage inter-pods) :

   sudo modprobe overlay
   sudo modprobe br_netfilter
   cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
   overlay
   br_netfilter
   EOF

   Configurez les paramètres sysctl pour autoriser le forward IP et le traçage iptables dans les bridges — sans ces réglages, les pods ne pourront pas communiquer entre eux :

   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

   Confirmez avec sudo sysctl net.ipv4.ip_forward qui doit retourner 1. Si kubeadm init échoue avec [ERROR Swap] ou [ERROR FileContent--proc-sys-net-bridge-bridge-nf-call-iptables], re-vérifiez ces trois étapes.

2. 2

   Installer containerd et configurer SystemdCgroup

   Kubernetes 1.36 utilise containerd comme runtime par défaut. Installez-le et configurez-le pour utiliser le driver cgroup systemd (obligatoire avec kubelet) :

   sudo apt-get update
   sudo apt-get install -y containerd

   Générez la configuration par défaut, puis activez le driver systemd :

   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

   Redémarrez containerd et activez-le au boot :

   sudo systemctl restart containerd
   sudo systemctl enable containerd

   Vérifiez que le driver est bien actif :

   containerd config dump | grep SystemdCgroup
   # Résultat attendu : SystemdCgroup = true

   Si SystemdCgroup reste à false, kubelet échouera avec l’erreur failed to create fs watcher ou CRI v1 runtime API is not implemented. Dans ce cas, éditez manuellement /etc/containerd/config.toml, cherchez la section [plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runc.options] et forcez SystemdCgroup = true.

   Testez que containerd fonctionne :

   sudo ctr version
   # Devrait afficher containerd 1.7.x ou 2.x

3. 3

   Installer kubeadm, kubelet et kubectl v1.36

   Ajoutez le dépôt officiel Kubernetes. La clé GPG et le dépôt apt sont hébergés sur pkgs.k8s.io depuis la version 1.29 :

   sudo apt-get update
   sudo apt-get install -y apt-transport-https ca-certificates curl gpg
   curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.36/deb/Release.key | \n sudo gpg --dearmor -o /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.36/deb/ /' | \n sudo tee /etc/apt/sources.list.d/kubernetes.list

   Installez les trois composants et bloquez leurs mises à jour automatiques (une mise à jour non planifiée de kubelet peut casser le cluster) :

   sudo apt-get update
   sudo apt-get install -y kubelet kubeadm kubectl
   sudo apt-mark hold kubelet kubeadm kubectl

   Vérifiez l’installation :

   kubeadm version
   # GitVersion:"v1.36.x" kubectl version --client
   # Client Version: v1.36.x kubelet --version
   # Kubernetes v1.36.x

   Si kubeadm version retourne une version différente, vérifiez que le dépôt v1.36 est bien dans /etc/apt/sources.list.d/kubernetes.list et relancez sudo apt-get update && sudo apt-get install -y kubelet kubeadm kubectl.

   Source : Documentation officielle kubeadm

4. 4

   Initialiser le cluster avec kubeadm init et déployer Calico

   Sur le nœud control-plane, lancez l’initialisation avec le CIDR réseau de Calico (192.168.0.0/16) :

   sudo kubeadm init --pod-network-cidr=192.168.0.0/16

   L’opération prend 1 à 3 minutes. En cas d’erreur [ERROR Port-10250]: Port 10250 is in use, tuez le processus existant avec sudo lsof -i :10250 puis relancez. En cas d’échec, réinitialisez avec sudo kubeadm reset avant de recommencer.

   Copiez le kubeconfig pour que kubectl fonctionne sans sudo :

   mkdir -p /Users/user/.kube
   sudo cp /etc/kubernetes/admin.conf /Users/user/.kube/config
   sudo chown 01: /Users/user/.kube/config

   Vérifiez que le control-plane est visible :

   kubectl get nodes
   # NAME STATUS ROLES AGE VERSION
   # control-plane NotReady control-plane 60s v1.36.x

   Le statut NotReady est normal tant que le plugin réseau n’est pas déployé. Installez Calico :

   kubectl apply -f https://raw.githubusercontent.com/projectcalico/calico/v3.28.0/manifests/calico.yaml

   Attendez que tous les pods système passent en Running :

   kubectl get pods -n kube-system --watch
   # Attendre : coredns-xxx 1/1 Running

   Une fois les pods coredns en Running, vérifiez que le nœud est Ready :

   kubectl get nodes
   # NAME STATUS ROLES AGE VERSION
   # control-plane Ready control-plane 2m v1.36.x

   Si le nœud reste NotReady, inspectez les pods Calico : kubectl get pods -n kube-system -l k8s-app=calico-node et consultez les logs avec kubectl logs -n kube-system -l k8s-app=calico-node.

5. 5

   Joindre les nœuds workers et valider le cluster

   Sur chaque machine worker, exécutez la commande kubeadm join affichée à la fin de kubeadm init :

   sudo kubeadm join 192.168.1.10:6443 --token abcdef.0123456789abcdef \n --discovery-token-ca-cert-hash sha256:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

   Le token d’inscription expire après 24 heures. Si vous avez dépassé ce délai, générez un nouveau token sur le control-plane :

   kubeadm token create --print-join-command
   # Copiez-collez la sortie sur chaque worker

   Après avoir joint chaque worker, vérifiez que tous les nœuds sont Ready :

   kubectl get nodes
   # NAME STATUS ROLES AGE VERSION
   # control-plane Ready control-plane 5m v1.36.x
   # worker-1 Ready <none> 30s v1.36.x
   # worker-2 Ready <none> 30s

   Déployez un workload de test pour confirmer l’orchestration complète :

   kubectl create deployment nginx --image=nginx:1.27 --replicas=2
   kubectl expose deployment nginx --port=80 --type=NodePort
   kubectl get svc nginx

   Vérifiez que les pods tournent sur les workers :

   kubectl get pods -o wide
   # NAME READY STATUS NODE
   # nginx-xxxx-yyyy 1/1 Running worker-1
   # nginx-xxxx-zzzz 1/1 Running worker-2

   Si un pod reste en Pending, vérifiez les ressources : kubectl describe node worker-1 et les événements : kubectl get events --sort-by=.metadata.creationTimestamp. Les causes fréquentes sont un CPU/mémoire insuffisant ou un plugin réseau non déployé.

   Pour nettoyer le test : kubectl delete deployment nginx && kubectl delete svc nginx.