Kubernetes donne le meilleur de lui-même quand il dispose du matériel et gère lui-même chaque ressource. Sur du bare metal, il n'y a ni hyperviseur ni machine virtuelle (VM) sous vos nodes : le kubelet, le runtime de conteneurs et chaque pod profitent de tout le CPU, de toute la mémoire et de tout le stockage de la machine. Pour une équipe qui fait tourner des conteneurs en production, cela signifie des performances stables sous charge, un coût mensuel fixe au lieu d'une facturation cloud par node, et un contrôle total sur le réseau, la sécurité et le calendrier des correctifs. Ce guide d'installation de Kubernetes monte un cluster avec kubeadm, l'outil officiel de bootstrap de K8s, d'un serveur dédié Linux tout neuf jusqu'à une application en ligne avec certificats TLS et RBAC. Vous allez préparer l'OS, configurer containerd, initialiser le control plane, ajouter le réseau des pods, exposer une application de test et sécuriser le cluster, une section après l'autre. Si vous découvrez le bare metal, notre guide pour héberger un serveur dédié couvre d'abord les bases. Les offres démarrent à 9,99 €/mois.

Points clés à retenir

  • L'outil de bootstrap exige au moins 2 CPU et 2 Go de RAM par node, le swap désactivé et un nom d'hôte unique.
  • Kubernetes ne tourne plus sur Docker Engine : installez containerd comme runtime, avec le driver cgroup systemd.
  • Une seule machine peut faire tourner un cluster complet : retirez le taint du control plane pour que les pods puissent y être planifiés.
  • Le bare metal n'a pas de load balancer cloud. Utilisez NodePort pour les tests et MetalLB pour de vrais services LoadBalancer.
  • Prérequis : un accès SSH avec sudo, environ 60 minutes, et un nom de domaine si vous voulez du TLS.

Introduction

Il existe plusieurs façons de faire tourner Kubernetes sur votre propre matériel. Les distributions légères comme K3s tiennent tout dans un seul binaire. L'outil officiel de bootstrap prend le contre-pied : il installe Kubernetes upstream, composant par composant, exactement tel que le projet le livre. C'est donc la plateforme de référence pour comprendre le fonctionnement d'un cluster, et la base la plus portable si vous migrez plus tard vos workloads chez un autre fournisseur.

Pourquoi pas un service Kubernetes managé ? Les fournisseurs de cloud public vendent du Kubernetes managé parmi leurs services cloud, facturé par node, par load balancer et par gigaoctet de trafic. Kubernetes sur serveurs dédiés échange ce confort contre la maîtrise des coûts et des performances stables : un prix mensuel fixe, des cœurs physiques et une latence réduite, puisqu'aucune couche de virtualisation ne s'intercale entre vos pods et le matériel. Il s'intègre aussi dans une architecture de cloud hybride, de cloud privé ou multi-cloud, avec les mêmes outils cloud native sur votre propre infrastructure, ce qui en fait une solution d'entreprise solide avec un budget prévisible. La contrepartie : c'est votre équipe DevOps qui gère le control plane, et non la plateforme cloud.

À la fin de cette installation de cluster Kubernetes, vous aurez :

  • Un control plane sur une machine dédiée, avec etcd, l'API server, le scheduler et le controller manager.
  • containerd comme runtime de conteneurs et Flannel ou Calico pour le réseau des pods.
  • Une application de test exposée sur le réseau.
  • cert-manager pour les certificats TLS et RBAC pour le contrôle d'accès.

Les mêmes étapes fonctionnent sur un ou plusieurs hôtes. Ajouter un worker plus tard ne demande qu'une commande join par node.

Prérequis et configuration matérielle

Configuration matérielle. D'après la documentation officielle, Kubernetes exige au minimum 2 CPU et 2 Go de RAM par node, plus assez d'espace disque pour les images de conteneurs. Cela suffit pour le control plane, guère plus. Les besoins en ressources de Kubernetes augmentent avec ce que vous exécutez : dimensionnez donc CPU, RAM et stockage selon votre environnement réel :

UsageCPURAMDisque
Lab, un node416 GoSSD
Node d'un petit cluster de prod4 à 832 GoNVMe en RAID 1
Services gourmands en base de données8+64 GoNVMe en RAID 1

Deux configurations Kimsufi répondent bien aux besoins d'un premier cluster Kubernetes, et voici leurs caractéristiques. Le serveur dédié KS-1 embarque un Intel Xeon-D 1520 à 8 threads et 32 Go de mémoire ECC. Le serveur dédié KS-1-B associe un Intel Xeon D-2123IT à 32 Go de mémoire ECC, extensible à 64 Go, et deux SSD NVMe en RAID logiciel, ce qu'etcd apprécie. Les deux modèles Xeon sont disponibles dans des data centers européens. Un thread Xeon physique se comporte tout autrement qu'un vCPU partagé sur une machine virtuelle : aucun autre client ne se le dispute, et aucune VM ne lui vole de cycles.

Logiciel. Une distribution Linux serveur stable, en 64 bits : Kubernetes sur Linux est la cible de référence. Ce guide utilise Ubuntu 24.04 LTS en amd64 ; sur d'autres distributions, suivez les instructions d'installation de la documentation Kubernetes.

Réseau. Une adresse publique, un nom d'hôte unique par node, et ces ports ouverts entre les nodes :

PortProtocoleComposant
6443TCPEndpoint de l'API Kubernetes
2379-2380TCPetcd
10250TCPAPI du kubelet
10257, 10259TCPcontroller manager, scheduler
30000-32767TCPServices NodePort
8472UDPOverlay VXLAN

Préparer le serveur dédié (installation de l'OS)

Installez Ubuntu 24.04 LTS pour amd64 depuis le modèle du panneau de contrôle, comme le montre notre guide d'installation d'Ubuntu Server. Kimsufi le provisionne en quelques minutes, puis vous envoie les identifiants par e-mail. Connectez-vous en SSH et ouvrez un shell root avec sudo -i : les commandes de cette section et de la suivante s'exécutent en root. Mettez le système à jour et définissez un nom d'hôte :

bash
apt update && apt upgrade -y
hostnamectl set-hostname k8s-cp1

Si SSH ne répond plus, la console distante du panneau de contrôle vous donne un accès direct à la machine. Utilisez-la pour corriger la configuration réseau sans réinstaller.

Désactiver le swap. Le kubelet attend un swap désactivé, sauf si vous configurez explicitement sa prise en charge. Désactivez-le et commentez la ligne swap dans /etc/fstab :

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

Modules du noyau et sysctl. Le réseau des pods exige que le trafic bridgé passe par iptables et que l'IP forwarding soit actif. Assurez-vous que les deux persistent après un redémarrage :

bash
cat <<EOF > /etc/modules-load.d/k8s.conf
overlay
br_netfilter
EOF
modprobe overlay && modprobe br_netfilter
cat <<EOF > /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1
EOF
sysctl --system

Installer le runtime de conteneurs (containerd)

Le projet a supprimé sa prise en charge intégrée de Docker (dockershim) dans la version 1.24 : installer Docker ne fait donc plus partie de la procédure. Docker Engine sert toujours à créer des images sur votre poste ou sur un hôte Docker dédié, mais le cluster dialogue avec un runtime CRI. containerd est le choix standard, et c'est celui sur lequel Docker lui-même s'appuie. Notre comparatif Kubernetes vs Docker explique comment les deux outils se répartissent le travail. Les images construites avec Podman plutôt que Docker fonctionnent de la même façon, puisque les deux produisent des images OCI.

Installez containerd depuis les dépôts Ubuntu et générez sa configuration de base :

bash
apt install -y containerd
mkdir -p /etc/containerd
containerd config default > /etc/containerd/config.toml

Ubuntu utilise systemd comme processus d'init, containerd doit donc aussi utiliser le driver cgroup systemd. Passez SystemdCgroup = true dans cette configuration, puis redémarrez le service :

bash
sed -i 's/SystemdCgroup = false/SystemdCgroup = true/' /etc/containerd/config.toml
systemctl restart containerd

Tapez exit pour quitter le shell root avant la section suivante.

⚠️ Attention Un driver cgroup différent entre containerd et le kubelet est la cause la plus fréquente d'un cluster neuf qui ne passe jamais Ready. Vérifiez ce réglage avant de continuer.

Installer kubeadm, kubelet et kubectl

Les trois composants Kubernetes proviennent du dépôt officiel Kubernetes sur pkgs.k8s.io, qui publie un dépôt par version mineure. Ajoutez le dépôt v1.37 et sa clé de signature :

bash
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.37/deb/Release.key | gpg --dearmor | sudo tee /etc/apt/keyrings/kubernetes.gpg >/dev/null
echo 'deb [arch=amd64 signed-by=/etc/apt/keyrings/kubernetes.gpg] https://pkgs.k8s.io/core:/stable:/v1.37/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list

Installez ensuite kubeadm, kubelet et kubectl, et bloquez leur version, pour qu'un apt upgrade de routine ne modifie jamais votre cluster à votre insu :

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

Chaque paquet a un rôle :

  • kubeadm initialise le control plane et fait rejoindre les nodes.
  • kubelet est l'agent du node qui exécute les pods. Son binaire se trouve dans /usr/bin, géré par systemd.
  • kubectl est le client qui vous sert à gérer chaque ressource du cluster.

Le kubelet redémarre toutes les quelques secondes tant que le cluster n'est pas initialisé. C'est normal, ce n'est pas une erreur.

Initialiser le control plane Kubernetes

Initialisez le control plane avec la plage réseau des pods qu'attend Flannel :

bash
sudo kubeadm init --pod-network-cidr=10.244.0.0/16

L'initialisation lance des vérifications préalables, génère les certificats, écrit les manifests de static pods pour l'API server, le controller manager, le scheduler et etcd, puis affiche une commande join avec un token. Conservez cette sortie : les worker nodes en ont besoin.

Donnez à votre utilisateur habituel l'accès au cluster, et exportez le chemin de la configuration pour le shell courant. Ajoutez la même ligne export dans ~/.bashrc pour la conserver :

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

Installation de Kubernetes sur un seul node. Par défaut, le control plane refuse les workloads ordinaires. Sur un serveur dédié unique, retirez ce taint pour que les pods puissent être planifiés :

bash
kubectl taint nodes --all node-role.kubernetes.io/control-plane-

Les anciens guides d'installation de master node Kubernetes utilisent node-role.kubernetes.io/master à la place. Le label master a été abandonné au profit de control-plane : les extraits copiés d'un tutoriel de l'époque « master » échouent donc silencieusement sur les versions actuelles.

Configurer le réseau (Flannel / Calico)

Les plugins réseau de Kubernetes, aussi appelés network add-ons, ne font pas partie de l'étape d'initialisation. Tant que vous n'en installez pas un, le node reste NotReady et les pods CoreDNS restent en attente. Choisissez-en un :

Flannel est le plus simple. Il construit un overlay VXLAN et fonctionne avec la plage 10.244.0.0/16 utilisée plus haut. Téléchargez son manifest depuis la dernière release GitHub du projet, puis appliquez-le avec kubectl apply -f kube-flannel.yml.

Calico demande quelques étapes de plus, mais applique les NetworkPolicy, ce que l'overlay par défaut ne fait pas seul. Choisissez-le si vous devez restreindre le trafic entre pods, par exemple pour isoler un namespace de prod. Créez l'opérateur Tigera, puis une custom resource avec le même CIDR de pods.

Vérifiez le résultat :

bash
kubectl get nodes
kubectl get pods -n kube-system

✅ Résultat attendu Le node affiche Ready, et les pods CoreDNS, du plugin réseau et du proxy affichent tous Running.

Déployer une application de test

Déployez un workload de test avec deux replicas, exposez-le et vérifiez le service :

bash
kubectl create deployment hello --image=nginx --replicas=2
kubectl expose deployment hello --port=80 --type=NodePort
kubectl get pods -l app=hello
kubectl get svc hello

Ouvrez http://<node-ip>:<node-port> dans un navigateur pour voir la page nginx. Quand les deux replicas sont prêts, votre premier déploiement Kubernetes est en ligne. Vérifiez son état à tout moment avec la sous-commande rollout status.

Load balancers sur bare metal. Dans un cloud, type: LoadBalancer demande au fournisseur un load balancer externe. Sur un serveur dédié, il n'y a pas de fournisseur cloud, et le service reste pending indéfiniment. Deux options :

  • MetalLB attribue à chaque service LoadBalancer une adresse issue d'un pool que vous définissez, par exemple une IP additionnelle routée vers le serveur.
  • Un ingress controller comme ingress-nginx, exposé via MetalLB ou sur les ports 80 et 443, route de nombreux domaines via une seule adresse publique.

Un pool MetalLB tient en un court manifest, chargé avec kubectl apply -f pool.yaml une fois MetalLB lui-même lancé :

yaml
apiVersion: metallb.io/v1beta1
kind: IPAddressPool
metadata:
  name: public
  namespace: metallb-system
spec:
  addresses:
    - 203.0.113.10/32

Sur un seul node, l'architecture la plus simple consiste à déployer ingress-nginx derrière ce load balancer : chaque nouvelle application se déploie alors comme une règle Ingress, et non comme un nouveau port. La Gateway API, successeur plus récent d'Ingress, suit la même logique avec des règles de routage du trafic et de load balancing plus riches.

Sécuriser le cluster : cert-manager et RBAC

TLS avec cert-manager. cert-manager demande et renouvelle des certificats Let's Encrypt pour vos ressources Ingress. Chargez son manifest de release ; cert-manager aura ensuite besoin d'un ClusterIssuer :

yaml
apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
  name: letsencrypt
spec:
  acme:
    server: https://acme-v02.api.letsencrypt.org/directory
    email: admin@example.com
    privateKeySecretRef: { name: letsencrypt }
    solvers:
      - http01: { ingress: { ingressClassName: nginx } }

Ajoutez l'annotation cert-manager.io/cluster-issuer: letsencrypt à chaque Ingress. Faites d'abord pointer un enregistrement DNS de votre domaine vers le node, et vérifiez que le port 80 est joignable, sinon le challenge HTTP échoue. cert-manager gère ensuite seul chaque renouvellement.

RBAC. Ne distribuez jamais admin.conf. Créez un ServiceAccount ou un utilisateur par personne ou par pipeline, lié à un Role limité à un seul namespace :

bash
kubectl create namespace prod
kubectl create rolebinding dev-edit --clusterrole=edit --user=dev@example.com -n prod

Pare-feu. Limitez le port 6443 à votre adresse d'administration et aux autres nodes, et fermez les ports d'etcd et du kubelet à Internet. Notre guide de configuration du pare-feu détaille les règles.

Secrets. Activez le chiffrement au repos des Secrets dans le fichier de configuration de l'API server : par défaut, ils sont seulement encodés en base64 dans etcd.

Sécurité des pods. Attribuez à chaque namespace un label de niveau Pod Security Standards, comme restricted, pour que la politique d'admission intégrée rejette les conteneurs privilégiés. Avec RBAC et NetworkPolicy, vous couvrez ainsi les bases de la sécurité cloud sur votre propre infrastructure cloud.

Supervision, logs et montée en charge

Supervision. Déployez metrics-server pour suivre l'utilisation des ressources en direct, puis installez kube-prometheus-stack avec Helm pour Prometheus, Grafana et les alertes. Ajoutez Loki pour collecter les logs des conteneurs dans le même tableau de bord Grafana, et surveillez l'occupation du stockage sur chaque disque : les logs grossissent vite.

Montée en charge. La montée en charge se joue à deux niveaux. Dans le cluster, un HorizontalPodAutoscaler ajoute des replicas quand la charge CPU augmente. En dehors, vous ajoutez des nodes : installez containerd et les trois paquets sur un deuxième serveur dédié, puis lancez la commande join avec le token conservé plus tôt. C'est toute l'installation d'un cluster Kubernetes multi-node : les mêmes étapes sur chaque worker.

Outils de gestion Kubernetes. Au quotidien, la gestion d'un cluster Kubernetes est plus simple avec une interface en terminal comme k9s ou un client de bureau comme Headlamp. Tous deux lisent votre kubeconfig, que kubectl config view affiche, et ce fichier de configuration Kubernetes est tout ce dont ils ont besoin. Gardez vos manifests dans Git en infrastructure as code, pour que plusieurs personnes puissent relire chaque modification.

Mises à jour. Kubernetes publie une nouvelle version mineure environ trois fois par an, chacune maintenue pendant environ 14 mois. Avancez d'une version mineure à la fois avec kubeadm upgrade apply, après avoir débloqué les paquets, et vérifiez que chaque node tourne sur la même version avant la mise à jour suivante. Notre guide de maintenance d'un serveur dédié couvre la routine qui l'accompagne.

Sauvegardes et reprise après sinistre. Faites régulièrement un snapshot d'etcd avec etcdctl snapshot save et copiez chaque snapshot hors du node, idéalement vers un stockage objet compatible S3 dans un autre data center. Sauvegardez séparément les données des volumes persistants : etcd ne contient que l'état du cluster. Pour la haute disponibilité plus tard, faites tourner trois nodes de control plane.

Conclusion

Ce tutoriel d'installation de Kubernetes transforme des serveurs dédiés en clusters Kubernetes standard en une heure environ : containerd, un control plane, un plugin réseau et votre première application. Ensuite, le travail devient opérationnel : TLS, RBAC, supervision, sauvegardes et mises à jour régulières. Commencez avec un node, et ajoutez-en quand vos workloads l'exigent.

Déployez votre cluster Kubernetes sur du bare metal Serveurs dédiés Kimsufi à partir de 9,99 €/mois. Accès root, tarif mensuel fixe, protection anti-DDoS intégrée.

FAQ

Kubernetes est-il toujours pertinent en 2026 ?

Absolument. Il reste la plateforme de référence pour faire tourner des conteneurs à grande échelle, portée par une vaste communauté Kubernetes, présente derrière la plupart des services de cloud computing et prise en charge par tous les grands fournisseurs cloud et la plupart des éditeurs on-premises. Ce qui a changé : les équipes choisissent désormais des distributions plus légères comme K3s pour les petites installations et réservent Kubernetes complet aux plateformes de production.

16 Go de RAM suffisent-ils pour Kubernetes ?

Pour un lab ou un petit cluster de production, oui. Le control plane lui-même consomme 2 à 3 Go. Le reste dépend de vos applications : les bases de données et les services Java remplissent vite la mémoire, 32 Go offrent donc plus de marge.

Pourquoi K8s est-il si difficile ?

Parce qu'il résout des problèmes difficiles : planification, réseau, stockage et reprise sur panne sur tout un parc d'hôtes. Cette installation expose chaque composant, ce qui explique son apparente complexité, et c'est aussi pour cela qu'elle est le meilleur moyen de comprendre comment fonctionne vraiment un cluster.

Peut-on héberger Kubernetes en local ?

Vous pouvez faire tourner Kubernetes en local avec kind, minikube ou K3s sur un ordinateur portable. Ces outils conviennent au développement. Pour tout ce dont d'autres personnes dépendent, un serveur dédié vous apporte une adresse publique, une disponibilité stable et des ressources physiques.

Quelle configuration matérielle minimale pour un node Kubernetes dédié ?

2 CPU et 2 Go de RAM constituent le plancher documenté. Un node réellement utile commence à 4 CPU, 16 Go de RAM et un stockage SSD.

Comment configurer le réseau d'un cluster à un seul node sur un serveur dédié ?

Initialisez avec un CIDR de pods, ajoutez un plugin réseau, retirez le taint du control plane et exposez les services via NodePort ou un ingress controller sur les ports 80 et 443. Installez MetalLB si vous avez besoin de services LoadBalancer.

Quelles mesures de sécurité appliquer quand on fait tourner Kubernetes sur bare metal ?

Restreignez le port de l'API, utilisez RBAC au lieu de partager admin.conf, chiffrez les Secrets au repos, appliquez des NetworkPolicy avec Calico, maintenez chaque composant à jour et sauvegardez etcd hors de la machine.