Comment installer Kubernetes sur Ubuntu 22.04 Jammy Jellyfish Linux
Kubernetes est un logiciel leader dans l’orchestration de conteneurs. Kubernetes fonctionne en gérant des clusters, qui sont simplement un ensemble d’hôtes destinés à l’exécution d’applications conteneurisées. Pour disposer d’un cluster Kubernetes, vous avez besoin d’un minimum de deux nœuds : un nœud maître et un nœud de travail. Bien sûr, vous pouvez étendre le cluster en ajoutant autant de nœuds de travail que nécessaire.
Dans ce tutoriel, nous allons déployer un cluster Kubernetes composé de deux nœuds, qui exécutent tous deux Ubuntu 22.04 Jammy Jellyfish. Avoir deux nœuds dans notre cluster est la configuration la plus basique possible, mais vous pourrez mettre à l’échelle cette configuration et ajouter d’autres nœuds si vous le souhaitez.
Dans ce tutoriel, vous allez apprendre :
- Comment installer Docker
- Comment installer Kubernetes
- Comment configurer un nœud maître et un nœud de travail
- Comment joindre un nœud de travail à un cluster Kubernetes
- Comment déployer Nginx (ou n’importe quelle application conteneurisée) dans un cluster Kubernetes
Scénario
Avant de plonger, établissons les détails de notre scénario. Comme mentionné ci-dessus, notre cluster va avoir deux nœuds, et ces deux nœuds exécutent Ubuntu 22.04 Jammy Jellyfish. L’un d’entre eux sera le nœud maître et pourra être facilement identifié par son nom d’hôte kubernetes-master. Le deuxième nœud sera notre nœud de travail et aura le nom d’hôte kubernetes-worker.
Le nœud maître déploiera un cluster Kubernetes et le nœud de travail le rejoindra simplement. Étant donné que les clusters Kubernetes sont conçus pour exécuter des logiciels conteneurisés, une fois que nous avons mis notre cluster en service, nous allons déployer un conteneur de serveur Nginx comme preuve de concept.
Installer Docker
Docker devra être installé sur les deux nœuds, car Kubernetes s’appuie sur celui-ci. Ouvrez un terminal de ligne de commande et tapez les commandes suivantes sur le nœud maître et le nœud actif pour installer Docker :
sudo apt update
sudo apt install docker.io
Une fois l’installation de Docker terminée, utilisez les commandes suivantes pour démarrer le service et vous assurer qu’il démarre automatiquement après chaque redémarrage :
sudo systemctl start docker
sudo systemctl enable docker
Installer Kubernetes
Nous sommes maintenant prêts à installer Kubernetes. Comme pour toutes les autres commandes jusqu’à présent, assurez-vous que vous le faites sur les deux nœuds. Sur votre maître et worker Kubernetes, installez d’abord le package apt-transport-https, qui nous permettra d’utiliser http et https dans les dépôts d’Ubuntu. C’est aussi le bon moment pour installer curl puisque nous en aurons besoin dans un instant :
sudo apt install apt-transport-https curl
Ensuite, ajoutez la clé de signature Kubernetes aux deux systèmes :
curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add
Ensuite, nous allons ajouter le référentiel de packages Kubernetes. Notez qu’au moment de la rédaction de cet article, Ubuntu 16.04 Xenial Xerus est le dernier dépôt Kubernetes disponible. Cela devrait éventuellement être remplacé par Ubuntu 22.04 Jammy Jellyfish, et la commande suivante peut alors être mise à jour de xenial à jammy.
sudo apt-add-repository "deb http://apt.kubernetes.io/ kubernetes-xenial main"
Maintenant, nous pouvons installer Kubernetes :
sudo apt install kubeadm kubelet kubectl kubernetes-cni
Désactiver la mémoire d’échange
Kubernetes refusera de fonctionner si votre système utilise la mémoire d’échange. Avant de continuer, assurez-vous que la mémoire d’échange est désactivée avec cette commande :
sudo swapoff -a
Cette commande désactivera la mémoire d’échange jusqu’à ce que vos systèmes redémarrent, donc pour que ce changement persiste, utilisez nano ou votre éditeur de texte préféré pour ouvrir ce fichier :
sudo nano /etc/fstab
À l’intérieur de ce fichier, commentez la ligne /swapfile en la faisant précéder d’un symbole #, comme indiqué ci-dessous. Ensuite, fermez ce fichier et enregistrez les modifications.
Définir les noms d’hôte
Ensuite, assurez-vous que tous vos nœuds ont un nom d’hôte unique. Dans notre scénario, nous utilisons les noms d’hôtes kubernetes-master et kubernetes-worker pour différencier facilement nos hôtes et identifier leurs rôles. Utilisez la commande suivante si vous devez modifier vos noms d’hôte :
sudo hostnamectl set-hostname kubernetes-master
Et sur le nœud worker :
sudo hostnamectl set-hostname kubernetes-worker
Vous ne remarquerez pas les modifications de nom d’hôte dans le terminal tant que vous n’en aurez pas ouvert un nouveau. Enfin, assurez-vous que tous vos nœuds ont une heure et une date précises, sinon vous rencontrerez des problèmes avec des certificats TLS invalides.
Initialiser le serveur maître Kubernetes
Nous sommes maintenant prêts à initialiser le nœud maître Kubernetes. Pour ce faire, entrez la commande suivante sur votre nœud maître :
kubernetes-master:~$ sudo kubeadm init
Le nœud maître Kubernetes est maintenant initialisé. La sortie nous donne une commande kubeadm join que nous devrons utiliser plus tard pour joindre notre ou nos nœuds de travail au nœud maître. Alors, prenez note de cette commande pour plus tard.
La sortie ci-dessus nous conseille également d’exécuter plusieurs commandes en tant qu’utilisateur normal pour commencer à utiliser le cluster Kubernetes. Exécutez ces trois commandes sur le nœud maître :
kubernetes-master:~$ mkdir -p $HOME/.kube
kubernetes-master:~$ sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
kubernetes-master:~$ sudo chown $(id -u):$(id -g) $HOME/.kube/config
Déployer un réseau d’espace
L’étape suivante consiste à déployer un réseau de pods. Le réseau de pods est utilisé pour la communication entre les hôtes et est nécessaire au bon fonctionnement du cluster Kubernetes. Pour cela, nous utiliserons le réseau de pods Flannel. Exécutez les deux commandes suivantes sur le nœud maître :
kubernetes-master:~$ kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml
kubernetes-master:~$ kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/k8s-manifests/kube-flannel-rbac.yml
En fonction de votre environnement, la mise en service de l’ensemble du réseau de flanelle peut prendre quelques secondes ou une minute. Vous pouvez utiliser la commande kubectl pour confirmer que tout est opérationnel et prêt :
kubernetes-master:~$ kubectl get pods --all-namespaces
Lorsque toute la colonne STATUS indique « En cours d’exécution », cela indique que tout est terminé et prêt à être déployé.
Rejoindre le cluster Kubernetes
Notre cluster est maintenant prêt à être rejoint par les nœuds de travail. Utilisez la commande kubeadm join récupérée précédemment à partir de la sortie d’initialisation du nœud maître Kubernetes pour rejoindre votre cluster Kubernetes :
kubernetes-worker:~$ sudo kubeadm join 192.168.1.220:6443 --token 1exb8s.2t4k3b5syfc3jfmo --discovery-token-ca-cert-hash sha256:72ad481cee4918cf2314738419356c9a402fb609263adad48c13797d0cba2341
De retour sur votre nœud maître Kubernetes, vérifiez que kubernetes-worker fait désormais partie de notre cluster Kubernetes à l’aide de cette commande :
kubernetes-master:~$ kubectl get nodes
Déploiement d’un service sur un cluster Kubernetes
Nous sommes maintenant prêts à déployer un service dans le cluster Kubernetes. Dans notre exemple, nous allons déployer un serveur Nginx dans notre nouveau cluster en tant que preuve de concept. Exécutez les deux commandes suivantes sur votre nœud maître :
kubernetes-master:~$ kubectl apply -f https://k8s.io/examples/controllers/nginx-deployment.yaml
kubernetes-master:~$ kubectl run --image=nginx nginx-server --port=80 --env="DOMAIN=cluster"
kubernetes-master:~$ kubectl expose deployment nginx-deployment --port=80 --name=nginx-http
Vous devez maintenant voir un nouveau conteneur docker nginx déployé sur votre nœud de travail :
kubernetes-worker:~$ sudo docker ps
Vous pouvez voir une liste en cours d’exécution de tous les services disponibles en cours d’exécution dans votre cluster à l’aide de la commande suivante, émise à partir du nœud maser Kubernetes :
kubernetes-master:~$ kubectl get svc
Réflexions finales
Dans ce tutoriel, nous avons appris à configurer Kubernetes pour déployer des applications conteneurisées sur Ubuntu 22.04 Jammy Jellyfish. Nous configurons un cluster de base composé de deux hôtes, un maître et un worker, bien qu’il puisse être mis à l’échelle à beaucoup plus de nœuds de travail si nécessaire.
Nous avons vu comment configurer Docker et d’autres prérequis, ainsi que déployer un serveur Nginx dans notre nouveau cluster en tant que preuve de concept. Bien entendu, cette même configuration peut être utilisée pour déployer n’importe quel nombre d’applications conteneurisées.