Comment installer Kubernetes sur un serveur Bare Metal

Présentation

Le déploiement de conteneurs et l'orchestration Kubernetes sont extrêmement puissants lorsqu'ils sont déployés dans des environnements virtuels. La flexibilité et les capacités d'évolutivité offrent des opportunités infinies.

Pourquoi alors ajouter un serveur physique à locataire unique au cluster ? Les machines virtuelles sont connues pour créer des problèmes de latence pour des applications spécifiques. L'accès direct au matériel peut être une solution à ce problème, notamment avec la possibilité d'ajouter des accélérateurs matériels (GPU).

Les développements de l'apprentissage automatique et de l'IA orientent les organisations vers la mise en œuvre de clusters Kubernetes sur les VM et les serveurs Bare Metal.

Ce didacticiel vous montre comment mettre en œuvre les concepts abordés dans notre article précédent sur l'architecture Kubernetes.

Suivez les étapes décrites et découvrez comment installer Kubernetes sur un serveur Bare Metal.

Prérequis

Plusieurs serveurs Linux
Un compte utilisateur sur chaque système avec sudo ou privilèges root
Accès à la ligne de commande/fenêtre du terminal
Leappartement gestionnaire de paquets (Debian 10)

Préparer le serveur Bare Metal pour l'installation de Kubernetes

Kubernetes est un outil d'orchestration hautement automatisé. Il communique entre les nœuds et prend des mesures pour répliquer les pods chaque fois que l'état actuel des clusters ne correspond pas à l'état souhaité.

Pour faciliter ce processus, la communication entre les nœuds doit être sans entrave. Chaque nœud doit être configuré afin que les paramètres de sécurité standard n'interfèrent pas avec les lignes de communication.

Les paramètres diffèrent en fonction de la distribution et doivent être appliqués à chaque nœud d'un cluster. Dans cet exemple, l'installation est effectuée à l'aide de Debian 10.

Si vous utilisez une autre distribution, consultez notre didacticiel sur l'installation de Kubernetes sur un système CentOS 7 ou Ubuntu 18.04.

Étape 1 :Désactiver SWAP

Les pods Kubernetes sont conçus pour utiliser pleinement les limites du processeur. Le kubelet n'est pas conçu pour utiliser la mémoire SWAP et doit donc être désactivé. Entrez la commande suivante dans la fenêtre de votre terminal pour désactiver SWAP :

sudo swapoff -a

Étape 2 :Résoudre nftables Problème de compatibilité avec le backend

Le kubeadm actuel les packages ne sont pas compatibles avec les nftables arrière-plan. Pour éviter tout problème, basculez les outils iptables vers leur mode hérité :

sudo update-alternatives --set iptables /usr/sbin/iptables-legacy
sudo update-alternatives --set ip6tables /usr/sbin/ip6tables-legacy
sudo update-alternatives --set arptables /usr/sbin/arptables-legacy
sudo update-alternatives --set ebtables /usr/sbin/ebtables-legacy

Étape 3 :Configurer le pare-feu

Les paramètres du pare-feu doivent être modifiés pour permettre la communication entre les pods au sein d'un cluster. Dans cet exemple, nous avons modifié les ports en utilisant ufw .

Pour ce faire, saisissez les commandes suivantes sur votre nœud maître :

sudo ufw allow 6443/tcp
sudo ufw allow 2379/tcp
sudo ufw allow 2380/tcp
sudo ufw allow 10250/tcp
sudo ufw allow 10251/tcp
sudo ufw allow 10252/tcp
sudo ufw allow 10255/tcp
sudo ufw reload

De plus, ces ports doivent être ouverts sur chaque nœud de travail :

sudo ufw allow 10251/tcp
sudo ufw allow 10255/tcp
sudo ufw reload

Étape 4 :Installer Docker

Un logiciel d'exécution de conteneur gère les images de conteneur sur les nœuds. Sans cela, Kubernetes ne peut pas accéder aux bibliothèques d'images et exécuter les applications dans les conteneurs. Pour cela, nous allons installer Docker.
Installez Docker sur tous les nœuds maîtres et travailleurs participant à votre cluster. Cela signifie que vous devez répéter ce processus sur chaque nœud à tour de rôle.

Accédez à votre interface de ligne de commande. La commande suivante met à jour les référentiels Debian et installe les packages. Il permet également à votre système d'utiliser des référentiels via un protocole sécurisé, HTTPS :

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

Maintenant, récupérez et ajoutez la clé GPG officielle de Docker en tapant :

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add –

La sortie confirme que l'action a été effectuée.

Nous avons ajouté la clé GPG et pouvons maintenant ajouter le référentiel apt de Docker :

sudo add-apt-repository \ "deb [arch=amd64] https://download.docker.com/linux/ubuntu \
$(lsb_release -cs) \ 
stable"

N'oubliez pas de mettre à jour vos dépôts :

sudo apt-get update

Le système est maintenant prêt pour l'installation de Docker CE.

Installez Docker à l'aide de la commande suivante :

sudo apt-get install docker-ce

Vérifiez si le service est actif avec :

docker -v

La ligne de commande confirme que le service est actif.

Vérifiez si le service fonctionne correctement en faisant appel à une image :

sudo docker run hello-world

Vous avez maintenant reçu la confirmation que Docker fonctionne correctement.

Étape 5 :Modifier le pilote du groupe de contrôle

Assurez-vous que docker-ce et Kubernetes utilisent le même "cgroup".

Vérifiez le groupe de contrôle docker actuel :

sudo docker info | grep -i cgroup

Le résultat ci-dessous confirme que Docker utilise "cgroupfs" comme pilote de groupe de contrôle.

Changez le pilote de cgroup Kubernetes en "cgroupfs" si nécessaire en tapant :

cat > /etc/docker/daemon.json <<EOF
{
"exec-opts": ["native.cgroupdriver=systemd"],
"log-driver": "json-file",
"log-opts": {
"max-size": "100m"
},
"storage-driver": "overlay2"
}
EOF

Rechargez le système systemd et redémarrez le service kubelet.

systemctl daemon-reload

systemctl restart kubelet

Nous avons sélectionné et installé un logiciel d'exécution de conteneur, dans ce cas, Docker. La section suivante explique comment installer Kubernetes et les outils dont nous avons besoin pour gérer Kubernetes.

Installer Kubernetes sur un serveur Bare Metal

Étape 1 :Téléchargez les référentiels Kubernetes

Téléchargez Kubernetes et ajoutez une clé de signature pour vous assurer que le logiciel est authentique :

curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add –

Nous recevons la confirmation que le colis est disponible.

Kubernetes n'est pas dans les référentiels par défaut. Pour les ajouter, saisissez la commande suivante sur chaque nœud du cluster :

sudo apt-add-repository "deb http://apt.kubernetes.io/ kubernetes-xenial main"

Étape 2 :Installez kubelet, kubeadm et kubectl

Pour pouvoir administrer Kubernetes, nous devons installer kubectl , un utilitaire utilisé pour envoyer des commandes au cluster. Nous devons également installer kubelet car il est essentiel pour déployer et contrôler les pods au sein d'un cluster. Kubeadm est le programme qui initialise Kubernetes lors du démarrage. Pour installer ces 3 outils indispensables, saisissez les commandes suivantes :

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

Le kubelet redémarre maintenant toutes les quelques secondes, car il attend dans une boucle de blocage pour kubeadm pour lui dire quoi faire.

Étape 3 :Initialiser Kubernetes sur le nœud maître

Saisissez la commande suivante sur le nœud maître :

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

Cela peut prendre plusieurs minutes jusqu'à ce que la sortie confirme que le cluster est actif :

Une fois que le système a terminé l'action, il affiche une jointure kubeadm message. Notez toute l'entrée. Vous en aurez besoin pour joindre les noeuds worker au cluster.

Étape 4 :Créer un répertoire pour le cluster Kubernetes

Faites fonctionner kubectl pour votre utilisateur non root, en exécutant ces commandes, qui font également partie de kubeadm init sortie :

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

Étape 5 :module complémentaire de réseau de pods (flanelle)

Installez un module complémentaire de réseau de pods pour que vos pods puissent communiquer efficacement. Flannel est un réseau superposé compatible avec Kubernetes. Pour installer Flannel tapez :

kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml

Étape 6 :Joindre le nœud de travail au cluster

Saisissez le kubeadm join commande sur chaque noeud worker. La clé que vous avez notée à l'étape 3 , connecte chaque nœud au cluster :

kubeadm join 10.0.2.15:6443 –token sv3ckz.fk2yooy92ieins26  \
--discovery-token-ca-cert-hash sha256:39d4a6ecc4a526b4aaff2594b469d43691fb7468688668f55d2a37690codo7fe

Attendez quelques minutes et vérifiez l'état des nœuds.

Basculez vers le serveur maître et saisissez :

kubectl get nodes

Le système affiche alors les noeuds worker que vous avez joints au cluster.