Installation de Kubernetes v1.28 sur Ubuntu 22.04

Ce guide décrit la mise en place d'un cluster Kubernetes v1.28 sur des machines virtuelles Ubuntu 22.04.3. Il couvre la configuration de trois nœuds maîtres et trois nœuds travailleurs.

Planification du déploiement

Le réseau de domaine commun est défini sur example.local, avec un VIP pour l'API Server. Les nœuds sont répartis comme suit :

Les versions logicielles ciblées sont :

• Docker CE 24.0.7 et containerd 1.6.26 comme moteur de conteneurs.
• Kubernetes 1.28.2 avec kubeadm, kubelet et kubectl.
• Flannel CNI version 0.3.1 pour la mise en réseau.

Tous les paquets sont récupérés depuis des dépôts miroirs en Chine pour accélérer le téléchargement.

Préparation du système d'exploitation

Les étapes suivantes doivent être exécutées sur chaque nœud.

Vérifications préliminaires Ubuntu

Assurez-vous que le pare-feu UFW est désactivé et que la synchronisation NTP est active.

# Vérifier l'état du pare-feu
sudo systemctl status ufw.service
# Confirmer la synchronisation de l'horloge
timedatectl show --property=NTPSynchronized

Désactivez le swap pour améliorer les performances de Kubernetes.

# Désactiver le swap
sudo swapoff -a
# Commenter la ligne swap dans /etc/fstab
sudo sed -i '/swap/s/^/#/' /etc/fstab

Configuration des dépôts APT

Ajoutez les sources APT pour Docker et Kubernetes.

# Ajouter la clé GPG et le dépôt Docker
curl -fsSL https://mirrors.cloud.aliyuncs.com/docker-ce/linux/ubuntu/gpg | sudo apt-key add -
sudo add-apt-repository "deb [arch=amd64] https://mirrors.cloud.aliyuncs.com/docker-ce/linux/ubuntu $(lsb_release -cs) stable"

# Ajouter la clé GPG et le dépôt Kubernetes
curl -fsSL https://mirrors.cloud.aliyuncs.com/kubernetes/apt/doc/apt-key.gpg | sudo apt-key add -
sudo add-apt-repository "deb https://mirrors.cloud.aliyuncs.com/kubernetes/apt/ kubernetes-xenial main"

Configuration des hôtes

Modifiez le fichier /etc/hosts sur tous les nœuds pour inclure les entrées correspondantes. Notez que le VIP est temporairement pointé vers ctrl01 pendant l'installation intiiale.

192.168.100.11 ctrl01.example.local ctrl01 api-vip.example.local api-vip
192.168.100.12 ctrl02.example.local ctrl02
192.168.100.13 ctrl03.example.local ctrl03
192.168.100.21 node01.example.local node01
192.168.100.22 node02.example.local node02
192.168.100.23 node03.example.local node03

Installation de Docker et containerd

Installez Docker et containerd sur tous les nœuds, puis configurez containerd pour qu'il utilise systemd comme gestionnaire de cgroups.

# Installer les paquets
sudo apt-get update && sudo apt-get install -y docker-ce docker-ce-cli containerd.io

# Générer la configuration containerd par défaut
containerd config default | sudo tee /etc/containerd/config.toml

# Modifier le fichier de configuration
sudo sed -i 's/SystemdCgroup = false/SystemdCgroup = true/' /etc/containerd/config.toml
sudo sed -i 's|sandbox_image = "registry.k8s.io/pause:3.6"|sandbox_image = "registry.aliyuncs.com/google_containers/pause:3.9"|' /etc/containerd/config.toml

# Redémarrer les services
sudo systemctl restart containerd.service docker.service

Vérifiez que les services sont actifs et en cours d'exécution.

Installation de Kubernetes

Sur tous les nœuds, installez les composants Kubernetes.

# Installer kubelet, kubeadm, kubectl
sudo apt-get install -y kubelet=1.28.2-00 kubeadm=1.28.2-00 kubectl=1.28.2-00

# Empêcher les mises à jour automatiques
sudo apt-mark hold kubelet kubeadm kubectl

Le service kubelet sera actif après l'initialisation du cluster.

Initialisation du nœud maître principal

Sur le nœud ctrl01, initialisez le cluster en utilisant kubeadm avec des paramètres personnalisés pour les images et le réseau.

# Tirer les images Kubernetes depuis le miroir
sudo kubeadm config images pull --kubernetes-version v1.28.2 --image-repository registry.aliyuncs.com/google_containers

# Initialiser le cluster
sudo kubeadm init \
  --control-plane-endpoint="api-vip.example.local" \
  --image-repository registry.aliyuncs.com/google_containers \
  --kubernetes-version v1.28.2 \
  --service-cidr=10.100.0.0/16 \
  --pod-network-cidr=10.200.0.0/16 \
  --ignore-preflight-errors=all

Configurez l'accès à kubectl pour l'utilisateur root.

export KUBECONFIG=/etc/kubernetes/admin.conf
echo 'export KUBECONFIG=/etc/kubernetes/admin.conf' >> ~/.bashrc
source ~/.bashrc

Déploiement du plugin réseau CNI

Utilisez Flannel pour établir la mise en réseau des pods. Téléchargez et appliquez la configuration.

# Télécharger le manifeste Flannel
curl -LO https://raw.githubusercontent.com/flannel-io/flannel/master/Documentation/kube-flannel.yml

# Vérifier que le réseau dans le fichier correspond au CIDR des pods
grep "Network" kube-flannel.yml

# Appliquer la configuration
kubectl apply -f kube-flannel.yml

Surveillez l'état des pods système jusqu'à ce qu'ils soient tous en cours d'exécution.

kubectl get pods -n kube-system -w

Ajout des autres nœuds au cluster

Générez un token d'adhésion permanent sur le nœud maître.

sudo kubeadm token create --print-join-command

Utilisez la commande générée sur les nœuds travailleurs et les autres maîtres. Pour les maîtres, ajoutez le drapeau --control-plane.

# Exemple pour un nœud travailleur
sudo kubeadm join api-vip.example.local:6443 --token <token> --discovery-token-ca-cert-hash sha256:<hash>

# Exemple pour un nœud maître additionnel
sudo kubeadm join api-vip.example.local:6443 --token <token> --discovery-token-ca-cert-hash sha256:<hash> --control-plane

Vérifiez que tous les nœuds sont dans l'état Ready.

kubectl get nodes

Démonstration d'une application

Déployez une application simple pour valider le cluster.

# Configurer crictl pour utiliser containerd
cat > /etc/crictl.yaml <<eof ajuster="" cr="" create="" crictl="" d="" de="" deployment="" docker.io="" eof="" expose="" exposer="" get="" image="" image-endpoint:="" kubectl="" l="" le="" nginx="" nombre="" pull="" r="" runtime-endpoint:="" scale="" service="" sudo="" svc="" tirer="" un="" une="" unix:="" v="" web-app=""></eof>

L'application sera accessible via le port NodePort affiché sur l'adresse IP de n'importe quel nœud du cluster. Par exemple, en utilisant l'IP du nœud maître avec le port correspondant.

Le cluster Kubernetes est maintenant opérationnel et prêt pour le déploiement d'applications conteneurisées.