Déployer votre premier cluster Kubernetes en 30 minutes avec kubeadm

Vous souhaitez déployer votre premier cluster Kubernetes avec kubeadm rapidement et efficacement ? Ce quickstart vous guide pas à pas, de la préparation des machines à votre première application déployée.

La formation déployer votre premier cluster Kubernetes en 30 minutes avec kubeadm devient accessible à tout développeur Backend ou administrateur système avec ce tutoriel.

TL;DR : kubeadm est l'outil officiel pour bootstrapper un cluster Kubernetes en moins de 30 minutes. Prérequis : 2 machines Linux (2 CPU, 2 Go RAM minimum), accès root, et connexion réseau. Vous exécuterez 6 commandes principales pour obtenir un cluster fonctionnel.

Cette compétence est au cœur de la formation LFS458 Administration Kubernetes.

Pourquoi kubeadm pour votre premier cluster ?

kubeadm est l'outil d'installation recommandé par la communauté Kubernetes. Il automatise la configuration du control plane tout en respectant les bonnes pratiques de sécurité. Selon le CNCF Annual Survey 2025, 82% des utilisateurs de conteneurs exécutent Kubernetes en production.

kubeadm gère automatiquement :

• La génération des certificats TLS
• La configuration d'etcd
• Le déploiement des composants du control plane
• La création du fichier kubeconfig admin

Pour comprendre ces composants, consultez l'architecture du control plane Kubernetes.

À retenir : kubeadm est le standard pour les installations manuelles de Kubernetes. Il prépare également à la certification CKA où cette compétence est évaluée.

Prérequis matériels et logiciels

Configuration minimale requise

Vérifications préalables

Exécutez ces commandes sur toutes les machines :

# Vérifier la configuration système
cat /etc/os-release
nproc
free -h
hostname

Désactivez le swap (obligatoire pour Kubernetes) :

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

Configurez les modules kernel requis :

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

Pour un guide détaillé sur les installations multi-nœuds, consultez le guide complet d'installation avec kubeadm.

Étape 1 : Installer containerd

containerd est le runtime de conteneurs recommandé pour Kubernetes depuis la version 1.24.

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

# Créer la configuration par défaut
sudo mkdir -p /etc/containerd
containerd config default | sudo tee /etc/containerd/config.toml

# Activer le driver cgroup systemd
sudo sed -i 's/SystemdCgroup = false/SystemdCgroup = true/' /etc/containerd/config.toml

# Redémarrer containerd
sudo systemctl restart containerd
sudo systemctl enable containerd

Vérifiez l'installation :

sudo systemctl status containerd

Étape 2 : Installer kubeadm, kubelet et kubectl

Ces trois outils constituent la base de tout cluster Kubernetes. kubelet est l'agent qui s'exécute sur chaque nœud.

# Ajouter le dépôt Kubernetes (version 1.32)
sudo apt-get install -y apt-transport-https ca-certificates curl gpg

curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.32/deb/Release.key | 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.32/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list

# Installer les packages
sudo apt-get update
sudo apt-get install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl

À retenir : La commande apt-mark hold empêche les mises à jour automatiques qui pourraient casser votre cluster.

Étape 3 : Initialiser le control plane

Sur la machine désignée comme control plane, exécutez kubeadm init :

sudo kubeadm init --pod-network-cidr=10.244.0.0/16 --apiserver-advertise-address=<IP_CONTROL_PLANE>

Remplacez par l'adresse IP de votre machine. Le paramètre --pod-network-cidr définit le réseau des pods, requis pour Flannel.

La commande génère une sortie contenant :

1. Les instructions pour configurer kubectl
2. La commande kubeadm join pour ajouter des workers

Configurez kubectl pour l'utilisateur courant :

mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

Vérifiez que le control plane répond :

kubectl get nodes
kubectl cluster-info

Pour approfondir la configuration réseau, consultez Configurer le réseau d'un cluster Kubernetes.

Étape 4 : Installer le plugin réseau CNI

Kubernetes nécessite un plugin CNI pour la communication entre pods. Flannel est le plus simple pour débuter.

kubectl apply -f https://github.com/flannel-io/flannel/releases/latest/download/kube-flannel.yml

Attendez que les pods système soient prêts :

kubectl get pods -n kube-system -w

Tous les pods doivent afficher Running avant de continuer.

Étape 5 : Joindre les worker nodes

Sur chaque machine worker, exécutez la commande kubeadm join générée à l'étape 3. Elle ressemble à :

sudo kubeadm join <IP_CONTROL_PLANE>:6443 --token <token> \
    --discovery-token-ca-cert-hash sha256:<hash>

Si vous avez perdu le token, regénérez-le depuis le control plane :

kubeadm token create --print-join-command

Vérifiez l'ajout des workers depuis le control plane :

kubectl get nodes

Tous les nœuds doivent afficher Ready après quelques secondes.

À retenir : Le token expire après 24 heures par défaut. Pour un usage en production, configurez des tokens permanents ou utilisez l'authentification par certificat.

Étape 6 : Déployer votre première application

Validez votre cluster avec un déploiement nginx :

# Créer un déploiement
kubectl create deployment nginx --image=nginx:1.27 --replicas=2

# Exposer le service
kubectl expose deployment nginx --port=80 --type=NodePort

# Vérifier le déploiement
kubectl get pods -o wide
kubectl get services

Testez l'accès à l'application :

NODE_PORT=$(kubectl get svc nginx -o jsonpath='{.spec.ports[0].nodePort}')
curl http://<IP_WORKER>:$NODE_PORT

Vous devriez voir la page d'accueil nginx.

Dépannage rapide

Pour plus de solutions, consultez la FAQ administration de cluster Kubernetes.

"Don't let your knowledge remain theoretical - set up a real Kubernetes environment to solidify your skills."
— TealHQ Kubernetes DevOps Guide

Quelle est la suite après ce premier cluster ?

Votre cluster fonctionne. Selon le rapport Spectro Cloud 2025, 80% des organisations exécutent Kubernetes en production avec une moyenne de 20+ clusters. Voici les prochaines étapes recommandées :

1. Monitoring : Installez Prometheus et Grafana pour surveiller votre cluster. Consultez le comparatif des outils de monitoring Kubernetes 2025.

1. Haute disponibilité : Configurez plusieurs control planes avec etcd distribué.

1. Sécurité : Appliquez des Network Policies et configurez RBAC. La formation LFS460 Sécurité Kubernetes couvre ces aspects.

1. Certification : La formation LFS458 Administration Kubernetes prépare à la certification CKA qui valide ces compétences.

Explorez également les fondamentaux de l'administration cluster Kubernetes et le guide complet Formation Kubernetes.

Pour les débutants souhaitant comprendre les concepts avant l'installation, la formation Kubernetes les fondamentaux offre une introduction d'une journée.

Passez à l'action

Vous avez déployé votre premier cluster Kubernetes fonctionnel. Comme le souligne The Enterprisers Project : "Anybody can learn Kubernetes. With abundant documentation and development tools available online, teaching yourself Kubernetes is very much within reach."

Pour maîtriser l'administration de clusters en production et préparer la certification CKA :

• LFS458 Administration Kubernetes : formation officielle Linux Foundation, 4 jours intensifs avec labs pratiques
• Kubernetes, les fondamentaux : découverte en 1 journée pour les équipes débutantes
• Demandez un devis personnalisé pour votre équipe

Contactez nos conseillers formation pour identifier le parcours adapté à vos objectifs.