Installer un cluster Kubernetes sur Ubuntu en utilisant kubeadm

Dans ce guide, je vais vous montrer les étapes pour installer et configurer un cluster Kubernetes fonctionnel de 3 nœuds sur Ubuntu Linux. Kubernetes est un système d'orchestration de conteneurs open-source utilisé pour automatiser le déploiement, la gestion et la mise à l'échelle des applications conteneurisées.

Dans cet article, nous partageons en détail le processus de :

Préparation des nœuds Kubernetes
Configuration des dépôts
Installation du moteur d'exécution de conteneurs
Installation des composants Kubernetes
Initialisation de votre cluster
installation du plugin réseau pour Kubernetes
Ajout de nouveaux nœuds de travail au cluster

Commençons !

Le guide ultime du bureau Ubuntu

Maîtrisez Ubuntu comme un pro – de la personnalisation élégante du bureau à l'automatisation puissante du terminal. Parfait pour les développeurs, les administrateurs systèmes et les utilisateurs avancés qui veulent un contrôle total de leur espace de travail.

Étape 1 : Diagramme des systèmes

Cette configuration est basée sur le diagramme suivant :

Configurons les noms d'hôte du système avant de pouvoir passer aux étapes suivantes :

Sur le nœud maître :

Définir le nom d’hôte comme suit :

sudo hostnamectl set-hostname k8s-master.example.com

Sur le nœud de travail 01 :

Définissez le nom d’hôte à l’aide de l’outil en ligne de commande hostnamectl.

sudo hostnamectl set-hostname k8s-node-01.example.com

Sur le nœud de travail 02 :

Définissez également le nom d'hôte pour le nœud de travail Kubernetes 02.

sudo hostnamectl set-hostname k8s-node-02.example.com

Une fois que le nom d'hôte correct a été configuré sur chaque hôte, remplissez chaque nœud avec les valeurs configurées.

$ sudo vim /etc/hosts
192.168.2.2 k8s-master.example.com    k8s-master
192.168.2.3 k8s-node-01.example.com  k8s-node-01
192.168.2.4 k8s-node-02.example.com  k8s-node-02

Déconnectez-vous et reconnectez-vous pour utiliser le nouveau nom d'hôte configuré.

exit||logout

Étape 2 : Créer un utilisateur administrateur

Avant d’effectuer toute configuration spécifique à Kubernetes, assurons-nous que toutes les dépendances sont satisfaites. Ici, nous allons mettre à jour le système et créer un utilisateur Kubernetes.

Mettre à jour les paquets du système vers la dernière version sur tous les nœuds :

sudo apt update && sudo apt upgrade -y
[ -e /var/run/reboot-required ] && sudo reboot

Ajouter un utilisateur pour gérer le cluster Kubernetes :

sudo useradd -s /bin/bash -m k8s-admin
sudo passwd k8s-admin
sudo usermod -aG sudo k8s-admin
echo "k8s-admin ALL=(ALL) NOPASSWD:ALL" | sudo tee /etc/sudoers.d/k8s-admin

Si vous préférez entrer le mot de passe sudo lorsque vous exécutez des commandes sudo en tant qu'utilisateur k8s-admin, vous pouvez alors ignorer la dernière ligne. Vous pouvez tester si aucune invite de mot de passe pour sudo apparaît :

$ su - k8s-admin
k8s-admin@k8s-master:~$ sudo su -
root@k8s-master:~# exit

Tout semble en ordre, procédons à l'installation du moteur Docker.

Étape 3 : Installer Containerd

Kubernetes nécessite un moteur d'exécution de conteneurs pour exécuter des conteneurs. Dans cet article, nous utiliserons Containerd comme moteur de conteneur.

Assurez-vous que Docker n'est pas installé. Sinon, désinstallez-le.

sudo apt remove docker docker-engine docker.io

Installer les dépendances :

sudo apt update
sudo apt install apt-transport-https ca-certificates curl software-properties-common

Importer la clé GPG du dépôt Docker :

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/trusted.gpg.d/docker-archive-keyring.gpg
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"

Installer le moteur Docker.

sudo apt update && sudo apt install containerd.io

Le service démarre automatiquement.

$ systemctl status containerd.service
● containerd.service - containerd container runtime
   Loaded: loaded (/lib/systemd/system/containerd.service; enabled; vendor preset: enabled)
   Active: active (running) since  Sun 2024-07-14 21:22:30 UTC; 34min ago
     Docs: https://containerd.io
  Process: 4265 ExecStartPre=/sbin/modprobe overlay (code=exited, status=0/SUCCESS)
 Main PID: 4270 (containerd)
    Tasks: 8
   CGroup: /system.slice/containerd.service
           └─4270 /usr/bin/containerd

Vous pouvez également vérifier la version installée :

containerd --version

Étape 4 : Installer les composants Kubernetes

Installer les outils dépendants.

sudo apt install apt-transport-https ca-certificates curl gpg -y

Définissez la version de Kubernetes que vous souhaitez installer.

k8s_ver=1.30

Téléchargez la clé de signature publique pour les dépôts de packages Kubernetes

curl -fsSL https://pkgs.k8s.io/core:/stable:/v${k8s_ver}/deb/Release.key | \
 sudo gpg --dearmor -o /etc/apt/trusted.gpg.d/k8s.gpg

Ajouter le dépôt APT officiel de Kubernetes.

echo "deb https://pkgs.k8s.io/core:/stable:/v${k8s_ver}/deb/ /" | sudo tee /etc/apt/sources.list.d/kubernetes.list

Mettre à jour l'index des paquets apt :

sudo apt update

Installer les composants Kubernetes

Installez kubectl, kubelet, kubernetes-cni et kubeadm, les composants principaux de Kubernetes :

sudo apt install kubectl kubelet kubeadm kubernetes-cni

Confirmez que tous les fichiers binaires du paquet sont présents sur le système de fichiers.

$ which kubelet
/usr/bin/kubelet

$ which kubeadm
/usr/bin/kubeadm

Si le swap est activé, désactivez-le.

sudo swapoff -a
sudo sed -i.bak -r 's/(.+ swap .+)/#\1/' /etc/fstab

Charger les modules requis.

sudo tee /etc/modules-load.d/containerd.conf <<EOF
overlay
br_netfilter
EOF

Pour charger à l’exécution, exécutez :

sudo modprobe overlay
sudo modprobe br_netfilter

Configurez également les paramètres sysctl.

sudo tee /etc/sysctl.d/kubernetes.conf<<EOF
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1
EOF

Charger les configurations.

sudo sysctl --system

Configurer containerd et redémarrer le service

sudo mkdir -p /etc/containerd
sudo containerd config default|sudo tee /etc/containerd/config.toml
sudo systemctl restart containerd

Activer le service kubelet

sudo systemctl enable kubelet

Étape 5 : Démarrer le plan de contrôle k8s

Toutes les commandes qui seront exécutées dans cette section doivent être lancées sur le nœud maître. N’exécutez aucune des commandes sur les nœuds de travail Kubernetes. Les composants maîtres de Kubernetes fournissent le plan de contrôle du cluster – Serveur API, Planificateur, Gestionnaire de contrôleur. Ils prennent des décisions globales concernant le cluster, par exemple la planification et la détection et la réponse aux événements du cluster.

Vérifiez que containerd fonctionne en téléchargeant les images de base de Kubernetes.

$ sudo kubeadm config images pull
[config/images] Pulled registry.k8s.io/kube-apiserver:v1.30.2
[config/images] Pulled registry.k8s.io/kube-controller-manager:v1.30.2
[config/images] Pulled registry.k8s.io/kube-scheduler:v1.30.2
[config/images] Pulled registry.k8s.io/kube-proxy:v1.30.2
[config/images] Pulled registry.k8s.io/coredns/coredns:v1.11.1
[config/images] Pulled registry.k8s.io/pause:3.9
[config/images] Pulled registry.k8s.io/etcd:3.5.12-0

Si vous avez plusieurs sockets CRI, veuillez utiliser --cri-socket pour en sélectionner un :

# Containerd
sudo kubeadm config images pull --cri-socket unix:///run/containerd/containerd.sock

# For CRI-O
sudo kubeadm config images pull --cri-socket unix:///var/run/crio/crio.sock

Bootstrap (nœud de plan de contrôle unique) – aucun point de terminaison partagé

Pour démarrer un cluster sans utiliser de point de terminaison DNS, exécutez :

sudo sysctl -p
sudo kubeadm init \
  --pod-network-cidr=172.24.0.0/16 \
  --cri-socket unix:///run/containerd/containerd.sock

Bootstrap avec point de terminaison partagé (nom DNS pour l’API du plan de contrôle)

Ceci est idéal pour plusieurs nœuds du plan de contrôle.

Définissez le nom DNS du point de terminaison du cluster ou ajoutez un enregistrement au fichier /etc/hosts.

$ sudo vim /etc/hosts
172.29.20.5 k8s-cluster.computingforgeeks.com

Créer un cluster :

sudo sysctl -p
sudo kubeadm init \
  --pod-network-cidr=172.24.0.0/16 \
  --upload-certs \
  --control-plane-endpoint=k8s-cluster.computingforgeeks.com

Où :

k8s-cluster.computingforgeeks.com pointe vers une IP de LB pour vos nœuds du plan de contrôle k8s.

Si tout se passe bien, vous devriez recevoir un message de succès avec les instructions sur la marche à suivre :

---
Your Kubernetes master has initialized successfully!

To start using your cluster, you need to run the following as a regular user:

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

You should now deploy a pod network to the cluster.
Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:
  https://kubernetes.io/docs/concepts/cluster-administration/addons/

You can now join any number of machines by running the following on each node
as root:

  kubeadm join 192.168.2.2:6443 --token 9y4vc8.h7jdjle1xdovrd0z --discovery-token-ca-cert-hash sha256:cff9d1444a56b24b4a8839ff3330ab7177065c90753ef3e4e614566695db273c

Configurer l'accès pour l'utilisateur `k8s-admin` sur le serveur maître

Passez à k8s-admin et copiez le fichier de configuration Kubernetes contenant les informations du cluster.

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

Valider le déploiement en vérifiant les informations du cluster.

$ kubectl cluster-info
Kubernetes control plane is running at https://192.168.2.2:6443
CoreDNS is running at https://192.168.2.2:6443/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy

To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.

Étape 6 : Installer le plugin CNI

Dans ce guide, nous utiliserons Calico. Vous pouvez choisir n’importe quel autre plugin réseau pris en charge.

Téléchargez les fichiers de l'opérateur et des ressources personnalisées. Consultez la page des versions pour la dernière version.

Obtenez la dernière version :

VERSION=$(curl --silent "https://api.github.com/repos/projectcalico/calico/releases/latest" | grep '"tag_name"' | sed -E 's/.*"([^"]+)".*/\1/')

Télécharger les ressources d'installation.

curl -O https://raw.githubusercontent.com/projectcalico/calico/${VERSION}/manifests/tigera-operator.yaml
curl -O https://raw.githubusercontent.com/projectcalico/calico/${VERSION}/manifests/custom-resources.yaml

Tout d'abord, installez l'opérateur sur votre cluster.

k8s-admin@k8s-master:~$ kubectl create -f tigera-operator.yaml
namespace/tigera-operator created
customresourcedefinition.apiextensions.k8s.io/bgpconfigurations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/bgpfilters.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/bgppeers.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/blockaffinities.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/caliconodestatuses.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/clusterinformations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/felixconfigurations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/globalnetworkpolicies.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/globalnetworksets.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/hostendpoints.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ipamblocks.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ipamconfigs.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ipamhandles.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ippools.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ipreservations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/kubecontrollersconfigurations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/networkpolicies.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/networksets.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/apiservers.operator.tigera.io created
customresourcedefinition.apiextensions.k8s.io/imagesets.operator.tigera.io created
customresourcedefinition.apiextensions.k8s.io/installations.operator.tigera.io created
customresourcedefinition.apiextensions.k8s.io/tigerastatuses.operator.tigera.io created
serviceaccount/tigera-operator created
clusterrole.rbac.authorization.k8s.io/tigera-operator created
clusterrolebinding.rbac.authorization.k8s.io/tigera-operator created
deployment.apps/tigera-operator created

Mettons également à jour le pool IP de Calico.

sed -ie 's/192.168.0.0/172.24.0.0/g' custom-resources.yaml

Puis appliquez les configurations du manifeste.

k8s-admin@k8s-master:~$  kubectl create -f custom-resources.yaml
installation.operator.tigera.io/default created
apiserver.operator.tigera.io/default created

Attendez que Calico Pod soit en état de fonctionnement.

k8s-admin@k8s-master:~$ kubectl get pods --all-namespaces
NAMESPACE          NAME                                             READY   STATUS    RESTARTS   AGE
calico-apiserver   calico-apiserver-5476c484c4-rmmts                1/1     Running   0          37s
calico-apiserver   calico-apiserver-5476c484c4-z9phf                1/1     Running   0          37s
calico-system      calico-kube-controllers-6945f87bd4-2xwx4         1/1     Running   0          80s
calico-system      calico-node-tkwtv                                1/1     Running   0          80s
calico-system      calico-typha-65f575c9fc-xx8m8                    1/1     Running   0          81s
calico-system      csi-node-driver-kngdn                            2/2     Running   0          80s
kube-system        coredns-5dd5756b68-77x77                         1/1     Running   0          11m
kube-system        coredns-5dd5756b68-plpd6                         1/1     Running   0          11m
kube-system        etcd-k8s-master.example.com                      1/1     Running   0          11m
kube-system        kube-apiserver-k8s-master.example.com            1/1     Running   0          11m
kube-system        kube-controller-manager-k8s-master.example.com   1/1     Running   0          11m
kube-system        kube-proxy-bxq4x                                 1/1     Running   0          11m
kube-system        kube-scheduler-k8s-master.example.com            1/1     Running   0          11m
tigera-operator    tigera-operator-94d7f7696-xls25                  1/1     Running   0          3m20s

Le nœud devrait maintenant être prêt.

k8s-admin@k8s-master:~$ kubectl get nodes
NAME                     STATUS   ROLES           AGE   VERSION
k8s-master.example.com   Ready    control-plane   20m   v1.30.2

Étape 7 : Configurer les nœuds de travail

Une fois le cluster Kubernetes initialisé et le nœud maître en ligne, commencez la configuration des nœuds de travail. Un nœud est une machine de travail dans Kubernetes, cela peut être une machine virtuelle ou physique. Chaque nœud est géré par le maître et dispose des services nécessaires pour exécuter les pods – docker, kubelet, kube-proxy.

1) Assurez-vous que le runtime Containerd est installé (couvré)

Suivez les étapes fournies dans cet article pour installer containerd

2) Ajouter le dépôt Kubernetes (couvert)

Assurez-vous que le dépôt pour les packages Kubernetes est ajouté au système.

3) Installer les composants Kubernetes (Étape 4)

Une fois que vous avez ajouté le dépôt Kubernetes, installez les composants en utilisant :

sudo apt install kubelet kubeadm kubectl kubernetes-cni

4) Joindre le nœud au cluster :

Utilisez la commande join donnée après l'initialisation du cluster Kubernetes. Vous pouvez afficher les commandes en utilisant :

kubeadm token create --print-join-command

Une fois terminé, vérifiez l'état des nœuds sur le maître :

k8s-admin@k8s-master:~$ kubectl get nodes
NAME          STATUS    ROLES     AGE       VERSION
k8s-master    Ready     master    35m       v1.30.2
k8s-node-01   Ready     <none>    2m        v1.30.2
k8s-node-02   Ready     <none>    1m        v1.30.2

Étape 8 : Valider la configuration de Kubernetes

Créer un espace de noms de test :

$ kubectl create namespace test
namespace/test created

Déployer l'application de test

kubectl create deployment hello-node --image=registry.k8s.io/e2e-test-images/agnhost:2.39 -- /agnhost netexec --http-port=8080

Voir les déploiements existants :

$ kubectl get deployments
NAME         READY   UP-TO-DATE   AVAILABLE   AGE
hello-node   1/1     1            1           1m

Voir les pods en cours d'exécution

$ kubectl get pods
NAME                          READY     STATUS    RESTARTS   AGE
hello-node-5f76cf6ccf-br9b5   1/1       Running   0          1m

Pour nettoyer les ressources, exécutez :

kubectl delete deployment hello-node

Étape 9 : Configurer l’auto-complétion de kubectl

Activez l’autocomplétion du shell pour les commandes kubectl. Kubectl inclut la prise en charge de l’autocomplétion, ce qui peut vous faire gagner beaucoup de frappe ! Pour activer l’autocomplétion du shell dans votre session actuelle, exécutez :

source <(kubectl completion bash)

Pour ajouter l’autocomplétion de kubectl à votre profil afin qu’elle se charge automatiquement dans les futures sessions de terminal, exécutez :

echo "source <(kubectl completion bash)" >> ~/.bashrc

Si vous utilisez zsh, modifiez le fichier ~/.zshrc et ajoutez le code suivant pour activer l’autocomplétion de kubectl :

if [ $commands[kubectl] ]; then
source <(kubectl completion zsh)
fi

Ou, si vous utilisez Oh-My-Zsh, modifiez le fichier ~/.zshrc et mettez à jour la ligne plugins= pour inclure le plugin kubectl.

source <(kubectl completion zsh)

Également pertinent est la commande Top pour les métriques des conteneurs

Matériel de formation pour la maîtrise de Kubernetes :

Meilleurs livres pour étudier Kubernetes

Conclusion

Nous avons réussi à déployer un cluster Kubernetes à 3 nœuds sur des serveurs Ubuntu LTS. Nos prochains guides couvriront la haute disponibilité de Kubernetes, la surveillance de Kubernetes, comment configurer un stockage externe et d'autres trucs intéressants. Restez à l'écoute !