Cet article détaille la procédure d'installation d'un cluster Kubernetes version 1.28.0 en utilisant Containerd comme runtime de conteneur.

I. Présentation Théorique

1.1 Containerd

Containerd est un runtime de conteneur open-source, responsable de la gestion et de l'exécution des conteneurs. Isolé du projet Docker en 2016, il se concentre sur les fonctionnalités essentielles telles que la gestion des images, le cycle de vie des conteneurs, ainsi que la gestion réseau et du stockage. Il offre un environnement d'exécution léger, autonome et intégrable.

Conçu comme un runtime générique, Containerd sert de base à de nombreuses plateformes de conteneurisation, y compris Kubernetes et Docker. Il n'est pas destiné à une utilisation directe par les utilisateurs finaux, mais plutôt à fournir une infrastructure de conteneurisation fiable pour des solutions de niveau supérieur.

Le fichier de configuration de containerd se trouve généralement sous /etc/containerd/config.toml et contient divers paramètres de configuration, tels que les dépôts d'images, les paramètres réseau et les arguments du runtime.

1.2 Relation entre Containerd et Docker

Containerd et Docker entretiennent une relation parent-enfant. Containerd est un composant central extrait du projet Docker. L'architecture de Docker Engine est modulaire et Containerd y est intégré comme un composant essentiel pour la gestion du cycle de vie et des opérations de base des conteneurs.

Par rapport à Docker, Containerd est plus léger et se focalise sur les fonctions de base du runtime de conteneur, excluant des fonctionnalités avancées comme la construction d'images ou l'orchestration.

II. Présentation de Kubernetes

2.1 Déploiement avec kubeadm

kubeadm est un outil officiel de la communauté Kubernetes permettant un déploiement rapide de clusters. Il simplifie la création d'un cluster en deux commandes principales :

• kubeadm init : Pour initialiser un nœud maître.
• kubeadm join : Pour joindre un nœud travailleur au cluster.

2.2 Prérequis d'Installation

Pour déployer un cluster Kubernetes, les machines doivent répondre aux exigences suivantes :

• Système d'exploitation : CentOS 7.9 (ou compatible).
• Matériel : Minimum 2 Go de RAM, 2 CPU et 30 Go d'espace disque par machine.
• Connectivité réseau : Toutes les machines du cluster doivent pouvoir communiquer entre elles.
• Accès Internet : Nécessaire pour télécharger les images de conteneur.
• Swap : Désactivé sur toutes les machines.

2.3 Configuration de l'Environnement

Voici la configuration proposée pour les nœuds du cluster :

Rôle	Configuration	Adresse IP	Composants
k8s-master	2C 2G	192.168.10.131	containerd, kubectl, kubeadm, kubelet
k8s-node01	2C 2G	192.168.10.132	containerd, kubectl, kubeadm, kubelet
k8s-node02	2C 2G	192.168.10.133	containerd, kubectl, kubeadm, kubelet

III. Mise en Place du Cluster Kubernetes

3.1 Initialisation du Système sur Tous les Nœuds

3.1.1 Mise à Jour du Noyau Linux

Pour améliorer la stabilité des clusters Kubernetes, il est recommandé d'utiliser un noyau Linux supérieur à la version 4.19.

# Vérifier la version actuelle du noyau
uname -r

# Télécharger les paquets du noyau (exemple avec une version spécifique)
wget -c http://193.49.22.109/elrepo/kernel/el7/x86_64/RPMS/kernel-ml-6.5.5-1.el7.elrepo.x86_64.rpm
wget -c http://193.49.22.109/elrepo/kernel/el7/x86_64/RPMS/kernel-ml-devel-6.5.5-1.el7.elrepo.x86_64.rpm

# Installer les paquets du noyau
yum localinstall -y kernel-ml*

# Afficher les entrées du menu de démarrage GRUB
awk -F\' '$1=="menuentry " {print i++ " : " $2}' /boot/grub2/grub.cfg

# Définir le noyau par défaut au démarrage (ici, le premier entré, index 0)
grub2-set-default 0

# Reconstruire le fichier de configuration GRUB
grub2-mkconfig -o /boot/grub2/grub.cfg

# Redémarrer le système
reboot

# Vérifier la nouvelle version du noyau
uname -r

3.1.2 Configuration du Nom d'Hôte et du Fichier hosts

# Définir le nom d'hôte pour chaque nœud
hostnamectl set-hostname k8s-master && bash
hostnamectl set-hostname k8s-node01 && bash
hostnamectl set-hostname k8s-node02 && bash

# Ajouter les entrées correspondantes dans le fichier /etc/hosts
cat >>/etc/hosts<<EOF
192.168.10.131 k8s-master
192.168.10.132 k8s-node01
192.168.10.133 k8s-node02
EOF

3.1.3 Installation des Paquets Courants

# Utiliser un miroir Aliyun pour les dépôts CentOS
curl -o /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
yum clean all && yum makecache

# Installer divers utilitaires et outils système
yum -y install vim lrzsz unzip wget net-tools tree bash-completion \
conntrack ntpdate ntp ipvsadm ipset iptables \
curl sysstat libseccomp git psmisc telnet unzip gcc gcc-c++ make

3.1.4 Désactivation du Pare-feu et SELinux

# Désactiver le service firewalld
systemctl disable firewalld --now

# Désactiver SELinux
sed -i 's/enforcing/disabled/g' /etc/selinux/config
setenforce 0

3.1.5 Désactivation de la Partition Swap

Kubernetes exige que la partition swap soit désactivée pour des raisons de performance.

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

3.1.6 Désactivation de NetworkManager

systemctl stop NetworkManager
systemctl disable NetworkManager

3.1.7 Ajustement des Paramètres du Noyau

cat >/etc/sysctl.d/kubernetes.conf<<EOF
net.bridge.bridge-nf-call-iptables=1
net.bridge.bridge-nf-call-ip6tables=1
net.ipv4.ip_forward=1
vm.swappiness=0
vm.overcommit_memory=1
EOF

# Appliquer les modifications immédiatement
sysctl --system

3.1.8 Ajustement des Limites de Ressources Linux

Cette étape optimise les limites de descripteurs de fichiers et de processus pour les applications gourmandes.

# Définir les limites pour un processus
ulimit -SHn 65535

# Configurer les limites globales dans /etc/security/limits.conf
cat >> /etc/security/limits.conf <<EOF
* soft nofile 655360
* hard nofile 131072
* soft nproc 655350
* hard nproc 655350
* soft memlock unlimited
* hard memlock unlimited
EOF

3.1.9 Synchronisation de l'Heure

# Installer chrony pour la synchronisation NTP
yum -y install chrony
systemctl restart chronyd
chronyc sources -v

# Synchroniser l'horloge système avec l'horloge matérielle
hwclock -s

3.1.10 Configuration de la Fonctionnalité IPVS

IPVS (IP Virtual Server) est utilisé par kube-proxy pour la répartition de charge.

# Installer les paquets requis pour IPVS
yum -y install ipvsadm ipset sysstat conntrack libseccomp

# Charger les modules nécessaires au démarrage
cat >>/etc/modules-load.d/ipvs.conf<<EOF
ip_vs
ip_vs_rr
ip_vs_wrr
ip_vs_sh
nf_conntrack_ipv4         # Pour les noyaux < 4.19, sinon utiliser nf_conntrack
ip_tables
ip_set
xt_set
ipt_set
ipt_rpfilter
ipt_REJECT
ipip
overlay
br_netfilter
EOF

# Redémarrer le service de chargement des modules
systemctl restart systemd-modules-load

# Vérifier que les modules sont chargés
lsmod | grep -e ip_vs -e nf_conntrack_ipv4

# Note: Sur les noyaux Linux 4.19+, nf_conntrack_ipv4 a été remplacé par nf_conntrack.

3.1.11 Installation de Containerd

Containerd est le runtime de conteneur requis pour Kubernetes à partir de la version 1.24.

# Configurer les modules du noyau pour containerd
cat >>/etc/modules-load.d/containerd.conf <<EOF
overlay
br_netfilter
EOF

# Charger les modules
modprobe overlay
modprobe br_netfilter

# Appliquer les modifications
sysctl --system

# Installer les dépendances
yum install -y yum-utils device-mapper-persistent-data lvm2

# Ajouter le dépôt logiciel Docker (qui inclut containerd)
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
yum makecache fast

# Afficher les versions disponibles de containerd et installer une version spécifique (exemple 1.6.16)
yum list containerd.io --showduplicates | sort -r
yum -y install containerd.io-1.6.16

# Générer le fichier de configuration par défaut de containerd
mkdir -p /etc/containerd
containerd config default >/etc/containerd/config.toml

# Configurer Systemd comme cgroup driver pour containerd
sed -i '/SystemdCgroup/s/false/true/g' /etc/containerd/config.toml

# Configurer un miroir pour le registry pause (important pour l'installation de k8s)
sed -i 's#registry.k8s.io/pause:3.6#registry.aliyuncs.com/google_containers/pause:3.9#g' /etc/containerd/config.toml

# Démarrer et activer containerd
systemctl enable containerd
systemctl start containerd
systemctl status containerd

# Vérifier la version de containerd
ctr version

3.1.12 Installation des Outils Kubeadm, Kubelet, Kubectl

# Ajouter le dépôt logiciel Kubernetes
cat <<eof>/etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=http://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64
enabled=1
gpgcheck=0
repo_gpgcheck=0
gpgkey=http://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg
http://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
EOF

# Mettre à jour le cache yum
yum makecache fast

# Installer des versions spécifiques des paquets Kubernetes (exemple v1.28.0)
yum list kubectl --showduplicates | sort -r
yum -y install kubectl-1.28.0 kubelet-1.28.0 kubeadm-1.28.0

# Configurer le cgroup driver pour kubelet (doit correspondre à containerd)
cat >/etc/sysconfig/kubelet<<EOF
KUBELET_EXTRA_ARGS="--cgroup-driver=systemd"
KUBE_PROXY_MODE="ipvs"
EOF

# Activer et démarrer kubelet
systemctl daemon-reload
systemctl enable kubelet

# Vérifier les versions installées
kubelet --version
kubeadm version
</eof>

3.1.13 Configuration de crictl

crictl est un outil en ligne de commande pour interagir avec les runtimes de conteneurs compatibles CRI.

# Configurer crictl pour utiliser containerd
cat <<eof debug:="" eof="" false="" image-endpoint:="" runtime-endpoint:="" tee="" timeout:="" unix:=""></eof>

3.1.14 Configuration d'un Miroir pour les Images Containerd

Utiliser un miroir peut accélérer le téléchargement des images nécessaires.

# Modifier le fichier de configuration containerd
vim /etc/containerd/config.toml

# Ajouter la section suivante pour spécifier un miroir (exemple)
# Assurez-vous de l'indentation correcte
[plugins."io.containerd.grpc.v1.cri".registry.mirrors]
  [plugins."io.containerd.grpc.v1.cri".registry.mirrors."docker.io"]
    endpoint = ["https://cf-workers-docker-io-8jv.pages.dev"] # Exemple de miroir, à adapter

# Redémarrer containerd pour appliquer les changements
systemctl restart containerd

3.2 Déploiement du Nœud Maître Kubernetes

3.2.1 Initialisation du Cluster

Pour connaître les versions des images requises par kubeadm, utilisez la commande suivatne :

kubeadm config images list --kubernetes-version=v1.28.0 --image-repository=registry.aliyuncs.com/google_containers

Pour télécharger ces images :

kubeadm config images pull --kubernetes-version=v1.28.0 --image-repository=registry.aliyuncs.com/google_containers

Vérifiez les images téléchargées :

crictl images ls

Méthode 1 : Initialisation manuelle avec IPVS

kubeadm init \
--apiserver-advertise-address=192.168.10.131 \
--image-repository=registry.aliyuncs.com/google_containers \
--kubernetes-version=v1.28.0 \
--pod-network-cidr=10.244.0.0/16 \
--service-cidr=10.96.0.0/12 \
--upload-certs | tee kubeadm-init.log

• --apiserver-advertise-address : L'adresse IP du nœud maître.
• --image-repository : Le dépôt d'images à utiliser.
• --kubernetes-version : La version de Kubernetes.
• --pod-network-cidr : Le réseau des Pods (doit correspondre au CNI choisi).
• --service-cidr : Le réseau des Services.
• --upload-certs : Permet de partager les certificats du contrôle plane pour l'ajout d'autres maîtres.

Méthode 2 : Initialisation avec fichier de configuration (Recommandé)

Générer un fichier de configuration par défaut :

kubeadm config print init-defaults > kubeadm-init.yaml
vim kubeadm-init.yaml

Modifiez le fichier kubeadm-init.yaml comme suit :

apiVersion: kubeadm.k8s.io/v1beta3
initConfiguration:
  nodeRegistration:
    criSocket: unix:///var/run/containerd/containerd.sock
    name: k8s-master
    taints:
    - effect: NoSchedule
      key: node-role.kubernetes.io/control-plane
---
apiVersion: kubeadm.k8s.io/v1beta3
clusterConfiguration:
  imageRepository: registry.aliyuncs.com/google_containers
  kubernetesVersion: 1.28.0
  networking:
    serviceSubnet: 10.96.0.0/12
    podSubnet: 10.244.0.0/16
---
apiVersion: kubeproxy.config.k8s.io/v1alpha1
kind: KubeProxyConfiguration
mode: ipvs # Utilisation de IPVS pour kube-proxy
---
apiVersion: kubelet.config.k8s.io/v1beta1
kind: KubeletConfiguration
cgroupDriver: systemd # Utilisation de systemd comme cgroup driver

Initialiser le cluster avec le fichier de configuration :

kubeadm init --config=kubeadm-init.yaml --upload-certs | tee kubeadm-init.log

Vérifier le mode de kube-proxy :

curl localhost:10249/proxyMode

En cas d'échec, consultez les logs de kubelet ou kubeadm-init.log.

Réinitialisation (si nécessaire)

# Sur les nœuds workers
kubeadm reset -f
rm -rf /etc/kubernetes/*

# Sur le nœud maître
kubeadm reset -f
rm -rf ~/.kube/
rm -rf /etc/kubernetes/*
rm -rf /var/lib/etcd/*
ipvsadm --clear

3.2.2 Configuration de l'Outil Kubectl

Configurez kubectl pour interagir avec le cluster.

# Créer le répertoire .kube s'il n'existe pas
mkdir -p $HOME/.kube

# Copier le fichier de configuration d'administration
cp -i /etc/kubernetes/admin.conf $HOME/.kube/config

# Définir la propriété du fichier
chown $(id -u):$(id -g) $HOME/.kube/config

# Option 1: Charger temporairement la variable d'environnement KUBECONFIG
# export KUBECONFIG=/etc/kubernetes/admin.conf

# Option 2: Charger de manière permanente (recommandé)
echo "export KUBECONFIG=/etc/kubernetes/admin.conf" >> ~/.bash_profile
source ~/.bash_profile

3.2.3 Vérification de l'État des Composants du Maître

kubectl get cs

3.2.4 Ajout des Nœuds Travailleurs au Cluster

Récupérez le token et le hash CA depuis la sortie de kubeadm init. Si vous avez perdu ces informations, vous pouvez les régénérer :

# Générer un nouveau token
openssl x509 -pubkey -in /etc/kubernetes/pki/ca.crt -noout | openssl rsa -in - -pubout -outform der | openssl dgst -sha256 -hex

# Obtenir le token (peut nécessiter une autre commande pour le retrouver s'il a expiré)
kubeadm token list

Exemple de commande pour joindre un nœud :

kubeadm join 192.168.10.131:6443 --token <votre_token> \
    --discovery-token-ca-cert-hash sha256:<votre_hash_ca>
</votre_hash_ca></votre_token>

3.2.5 Vérification de l'État des Nœuds du Cluster

Initialement, les nœuds apparaîtront comme "NotReady" en l'absence d'un plugin réseau CNI.

kubectl get nodes

3.2.6 Déploiement du Plugin Réseau CNI (Calico)

Kubernetes nécessite un plugin réseau CNI pour la communication inter-pods. Calico est un choix populaire.

# Télécharger le fichier de manifestes Calico (adapter la version si nécessaire)
wget --no-check-certificate https://docs.tigera.io/archive/v3.25/manifests/calico.yaml

# Modifier le fichier pour spécifier le CIDR du pod network
vim calico.yaml
# Recherchez et décommentez/modifiez la ligne suivante (souvent autour de la ligne 4601) :
# - name: CALICO_IPV4POOL_CIDR
#   value: "10.244.0.0/16" # Doit correspondre à --pod-network-cidr de kubeadm init

# Déployer Calico
kubectl apply -f calico.yaml

3.2.7 Vérification de l'État des Pods du Cluster

Une fois le CNI déployé, les pods devraient passer à l'état "Running".

kubectl get pods -A

Les fichiers manifestes des composants principaux (etcd, apiserver, etc.) se trouvent dans /etc/kubernetes/manifests/.

3.2.8 Vérification Finale de l'État des Nœuds

Les nœuds devraient maintenant être marqués comme "Ready".

kubectl get nodes

3.3 Configuration de l'Auto-complétion pour Kubectl sur le Maître

# 1) Installer bash-completion
yum install bash-completion -y

# 2) Charger bash_completion
source /usr/share/bash-completion/bash_completion

# 3) Activer l'auto-complétion pour kubectl
# Temporaire pour la session courante
source <(kubectl completion bash)
# Permanent (ajouter au fichier .bashrc)
echo "source <(kubectl completion bash)" >> ~/.bashrc
source ~/.bashrc

3.4 Test du Cluster Kubernetes

Déploiement et Test d'une Application Nginx

# Créer un déploiement Nginx avec 3 réplicas
kubectl create deployment nginx --image=nginx --replicas=3

# Exposer le déploiement en tant que service NodePort
kubectl expose deployment nginx --port=80 --target-port=80 --type=NodePort

# Afficher les pods et services (note: le maître peut avoir un taint qui empêche le déploiement de pods par défaut)
kubectl get pod,svc

# Tester l'accès via l'IP d'un nœud et le port du service NodePort
# Exemple: Accéder à http://<ip_du_n>:<port_nodeport> dans un navigateur.
</port_nodeport></ip_du_n>