Introduction
Kubernetes est un outil open-source qui est crucial pour l'orchestration de conteneurs. Kubernetes fonctionne en orchestrant et en gérant des clusters à grande échelle dans divers environnements cloud ou même sur des serveurs sur site. Un cluster est un ensemble d'hôtes destinés à exécuter des applications et des services conteneurisés. Un cluster a besoin d'un minimum de deux nœuds pour fonctionner – un maître nœud et un worker nœud. En gardant la scalabilité à l'esprit, vous avez la possibilité d'étendre le cluster avec autant de nœuds workers que nécessaire.
Un nœud dans Kubernetes fait référence à un serveur. Un nœud maître est un serveur qui gère l'état du cluster. Les nœuds workers sont des serveurs qui exécutent les charges de travail – ce sont généralement des applications et services conteneurisés.
Ce guide vous guidera à travers les étapes d'installation et de déploiement d'un cluster Kubernetes composé de deux nœuds sur Ubuntu 20.04. Comme mentionné, avoir deux nœuds est la configuration la plus basique lorsque vous travaillez avec Kubernetes. Vous avez également la possibilité d'ajouter d'autres nœuds workers une fois que vous aurez compris les bases. Nous vous montrerons ensuite comment lier les deux serveurs pour permettre au nœud maître de contrôler le nœud worker.
Pour tester notre configuration, nous allons déployer un Docker conteneur exécutant le serveur web Nginx sur le cluster. Il s'agit d'une application réelle typique de Kubernetes. Vous en apprendrez plus sur certains composants clés de Kubernetes tels que kubectl et kubeadm au fur et à mesure. Il est également conseillé de vous familiariser d'abord avec notre tutoriel sur la découverte des bases de la boîte à outils Kubernetes pour vous familiariser avec les bases de la plateforme Kubernetes.
Maintenant, commençons !
Prérequis
Vous devrez provisionner deux serveurs, fonctionnant sous Ubuntu 20.04. Pour de meilleures performances, la configuration système minimale requise pour Kubernetes est de 2 Go de RAM et 2 processeurs. Vous pouvez suivre les étapes 1 à 4 de ce tutoriel étape par étape pour vous aider à configurer votre serveur Ubuntu sur CloudSigma. Un serveur sera le nœud maître, l'autre sera le nœud worker. Nous avons judicieusement nommé nos deux serveurs kubernetes-master et kubernetes-worker. Cela facilite le suivi du tutoriel. Cependant, vous êtes libre de choisir les noms d'hôte que vous préférez.
-
Assurez-vous d'ajouter un utilisateur avec des privilèges sudo sur les deux nœuds, que nous utiliserons pour exécuter les commandes comme indiqué dans le tutoriel ci-dessus. Suivez ce tutoriel sur la configuration du fichier sudoers Linux pour obtenir des instructions.
-
Connectivité réseau – les serveurs du cluster doivent pouvoir communiquer. Lorsque vous déployez vos machines virtuelles depuis CloudSigma, elles seront connectées à Internet avec une IP publique par défaut. Si vous travaillez depuis un réseau local, vous devrez peut-être modifier votre fichier /etc/hosts dans chaque serveur et les lier de manière appropriée.
-
Vous devrez installer et activer Docker sur chacun des nœuds. Kubernetes s'appuie sur un runtime de conteneur pour exécuter des conteneurs dans des pods. Bien qu'il existe d'autres plateformes de conteneurs au choix, nous utiliserons Docker dans ce tutoriel. Docker fournira l'environnement d'exécution requis par Ubuntu. Vous pouvez suivre les étapes 1, 2 et 3 de notre tutoriel sur l'installation et l'utilisation de Docker.
Étape 1 : Installer Kubernetes
Dans cette étape, nous allons installer Kubernetes. Tout comme vous l'avez fait avec Docker dans les prérequis, vous devez exécuter les commandes sur les deux nœuds pour installer Kubernetes. Utilisez ssh pour vous connecter aux deux nœuds et continuer. Vous commencerez par installer le paquet apt-transport-https qui permet de travailler avec http et https dans les dépôts d'Ubuntu. Installez également curl car il sera nécessaire pour les étapes suivantes. Exécutez la commande suivante :
|
1 |
sudo apt install apt-transport-https curl |
Ensuite, ajoutez la clé de signature Kubernetes aux deux nœuds en exécutant la commande :
|
1 |
curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add |
Ensuite, nous ajoutons le dépôt Kubernetes comme source de paquets sur les deux nœuds à l'aide de la commande suivante :
|
1 2 |
echo "deb https://apt.kubernetes.io/ kubernetes-xenial main" >> ~/kubernetes.list sudo mv ~/kubernetes.list /etc/apt/sources.list.d |
Après cela, mettez à jour les nœuds :
|
1 |
sudo apt update |
- Installer les outils Kubernetes
Une fois la mise à jour terminée, nous installerons Kubernetes. Cela implique d'installer les différents outils qui composent Kubernetes : kubeadm, kubelet, kubectl, et kubernetes-cni. Ces outils sont installés sur les deux nœuds. Nous définissons chaque outil ci-dessous :
-
kubelet – un agent qui s'exécute sur chaque nœud et gère la communication avec le nœud maître pour lancer les charges de travail dans le runtime de conteneur. Saisissez la commande suivante pour installer kubelet :
|
1 |
sudo apt install kubelet |
-
kubeadm – fait partie du projet Kubernetes et aide à initialiser un cluster Kubernetes. Saisissez la commande suivante pour installer kubeadm :
|
1 |
sudo apt install kubeadm |
-
kubectl – l'outil en ligne de commande Kubernetes qui vous permet d'exécuter des commandes au sein des clusters Kubernetes. Exécutez la commande suivante pour installer kubectl :
|
1 |
sudo apt install kubectl |
-
kubernetes-cni – permet la mise en réseau au sein des conteneurs, garantissant que les conteneurs peuvent communiquer et échanger des données. Exécutez la commande suivante pour l'installer :
|
1 |
sudo apt-get install -y kubernetes-cni |
Optionnellement, vous pouvez installer les quatre en une seule commande :
|
1 |
sudo apt-get install -y kubelet kubeadm kubectl kubernetes-cni |
Étape 2 : Désactivation de la mémoire Swap
Kubernetes ne peut pas fonctionner sur un système qui utilise de la mémoire swap memory. Par conséquent, elle doit être désactivée sur le nœud maître et tous les nœuds de travail. Exécutez la commande suivante pour désactiver la mémoire swap :
|
1 |
sudo swapoff -a |
Cette commande désactive la mémoire swap jusqu'au redémarrage du système. Nous devons nous assurer qu'elle reste désactivée même après les redémarrages. Cela doit être fait sur le maître et tous les nœuds de travail. Nous pouvons le faire en modifiant le fichier fstab file et en commentant la ligne /swapfile avec un #. Ouvrez le fichier avec l'éditeur de texte nano en saisissant la commande suivante :
|
1 |
sudo nano /etc/fstab |
Dans le fichier, commentez la ligne swapfile comme indiqué dans la capture d'écran ci-dessous :
Si vous ne voyez pas la ligne swapfile, ignorez-la simplement. Enregistrez et fermez le fichier lorsque vous avez terminé les modifications. Suivez le même processus pour les deux nœuds. Désormais, les paramètres de la mémoire swap resteront désactivés, même après le redémarrage de votre serveur.
Étape 3 : Définition de noms d'hôte uniques
Vos nœuds doivent avoir des noms d'hôte uniques pour une identification plus facile. Si vous déployez un cluster avec de nombreux nœuds, vous pouvez le configurer pour identifier des noms pour vos nœuds de travail tels que node-1, node-2, etc. Comme nous l'avons mentionné précédemment, nous avons nommé nos nœuds kubernetes-master et kubernetes-worker. Nous les avons définis lors de la création du serveur. Cependant, vous pouvez ajuster ou définir les vôtres si vous ne l'avez pas déjà fait depuis la ligne de commande. Pour ajuster le nom d'hôte sur le nœud maître, exécutez la commande suivante :
|
1 |
sudo hostnamectl set-hostname kubernetes-master |
Sur le nœud de travail, exécutez la commande suivante :
|
1 |
sudo hostnamectl set-hostname kubernetes-worker |
Vous pouvez fermer la session de terminal actuelle et vous reconnecter en ssh au serveur pour voir les modifications.
Étape 4 : Permettre à Iptables de voir le trafic ponté
Pour que les nœuds maître et de travail voient correctement le trafic ponté, vous devez vous assurer que net.bridge.bridge-nf-call-iptables est défini sur 1 dans votre configuration. Tout d'abord, assurez-vous que le module br_netfilter est chargé. Vous pouvez le confirmer en lançant la commande :
|
1 |
lsmod | grep br_netfilter |
Optionnellement, vous pouvez le charger explicitement avec la commande :
|
1 |
sudo modprobe br_netfilter |
Maintenant, vous pouvez exécuter cette commande pour définir la valeur sur 1 :
|
1 |
sudo sysctl net.bridge.bridge-nf-call-iptables=1 |
Étape 5 : Modification du pilote de cgroup Docker
Par défaut, Docker s'installe avec “cgroupfs” comme pilote de cgroup. Kubernetes recommande que Docker devrait s'exécuter avec “systemd” comme pilote. Si vous ignorez cette étape et essayez d'initialiser kubeadm à l'étape suivante, vous obtiendrez l'avertissement suivant dans votre terminal :
|
1 2 |
[preflight] Exécution des pré--vol vérifications [AVERTISSEMENT IsDockerSystemdCheck]: détecté "cgroupfs" comme le Docker cgroup pilote. Le recommandé pilote est "systemd". Veuillez suivre le guide sur https://kubernetes.io/docs/setup/cri/ |
Sur les nœuds master et worker, mettez à jour le cgroupdriver avec les commandes suivantes :
|
1 2 3 4 5 6 7 8 9 |
sudo mkdir /etc/docker cat <<EOF | sudo tee /etc/docker/daemon.json { "exec-opts": ["native.cgroupdriver=systemd"], "log-driver": "json-file", "log-opts": { "max-size": "100m" }, "storage-driver": "overlay2" } EOF |
Ensuite, exécutez les commandes suivantes pour redémarrer et activer Docker au démarrage du système :
|
1 2 3 |
sudo systemctl enable docker sudo systemctl daemon-reload sudo systemctl restart docker |
Une fois cela configuré, nous pouvons passer aux choses sérieuses, le déploiement du cluster Kubernetes !
Étape 6 : Initialisation du nœud maître (Master) Kubernetes
La première étape du déploiement d'un cluster Kubernetes consiste à démarrer le nœud master. Depuis le terminal de votre nœud master, exécutez la commande suivante pour initialiser le kubernetes-master:
|
1 |
sudo kubeadm init --pod-network-cidr=10.244.0.0/16 |
Si vous exécutez la commande ci-dessus et que votre système ne répond pas aux exigences attendues, telles que la RAM ou le processeur minimum comme expliqué dans la section Prérequis, vous obtiendrez un avertissement et le cluster ne démarrera pas :
La capture d'écran ci-dessous montre que l'initialisation a réussi. Nous avons également ajouté une option pour spécifier le réseau de pods avec l'adresse IP 10.244.0.0. C'est l'adresse IP par défaut que kube-flannel utilise. Nous détaillerons davantage le réseau de pods à l'étape suivante.
Dans la sortie, vous pouvez voir la commande kubeadm join (nous avons masqué notre adresse IP) et un jeton unique que vous exécuterez sur le nœud worker et tous les autres nœuds workers que vous souhaitez joindre à ce cluster. Ensuite, copiez-collez cette commande car vous l'utiliserez plus tard sur le nœud worker.
Dans la sortie, Kubernetes affiche également des commandes supplémentaires que vous devez exécuter en tant qu'utilisateur standard sur le nœud master avant de commencer à utiliser le cluster. Exécutons ces commandes :
|
1 2 3 |
mkdir -p $HOME/.kube sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config sudo chown $(id -u):$(id -g) $HOME/.kube/config |
Nous avons maintenant initialisé le nœud master. Cependant, nous devons également configurer le réseau de pods sur le nœud master avant de joindre les nœuds workers.
Étape 7 : Déploiement d'un réseau de pods
Un réseau de pods facilite la communication entre les serveurs et est nécessaire au bon fonctionnement du cluster Kubernetes. Vous pouvez en savoir plus sur le Réseau de cluster Kubernetes dans la documentation officielle. Nous utiliserons le réseau de pods Flannel pour ce tutoriel. Flannel est un réseau superposé simple qui répond aux exigences de Kubernetes.
Avant de déployer le réseau de pods, nous devons vérifier l'état du pare-feu. Si vous avez activé le pare-feu après avoir suivi l'étape 5 du tutoriel sur la configuration de votre serveur Ubuntu, vous devez d'abord ajouter une règle de pare-feu pour créer des exceptions pour le port 6443 (le port par défaut pour Kubernetes). Exécutez les commandes ufw suivantes sur les nœuds master et worker :
|
1 2 |
sudo ufw allow 6443 sudo ufw allow 6443/tcp |
Après cela, vous pouvez exécuter les deux commandes suivantes pour déployer le réseau de pods sur le nœud master :
|
1 2 |
kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/k8s-manifests/kube-flannel-rbac.yml |
Cela peut prendre de quelques secondes à une minute selon votre environnement pour charger le réseau flannel. Exécutez la commande suivante pour confirmer que tout est démarré :
|
1 |
kubectl get pods --all-namespaces |
La sortie de la commande devrait afficher l'état de tous les services comme étant en cours d'exécution si tout a réussi :
Vous pouvez également afficher l' état de santé des composants à l'aide de la commande get component status :
|
1 |
kubectl get componentstatus |
Cette commande a une forme abrégée cs :
|
1 |
kubectl get cs |
Si vous voyez l'état « unhealthy » (non sain), modifiez les fichiers suivants et supprimez la ligne sous (spec->containers->command) contenant cette phrase - --port=0 :
|
1 |
sudo nano /etc/kubernetes/manifests/kube-scheduler.yaml |
Faites de même pour ce fichier :
|
1 |
sudo nano /etc/kubernetes/manifests/kube-controller-manager.yaml |
Enfin, redémarrez le service Kubernetes :
|
1 |
sudo systemctl restart kubelet.service |
Étape 8 : Joindre les nœuds workers au cluster Kubernetes
Avec le nœud maître Kubernetes- actif et le réseau de pods prêt, nous pouvons joindre nos nœuds workers au cluster. Dans ce tutoriel, nous n'avons qu'un seul nœud worker, nous allons donc travailler avec celui-ci. Si vous avez d'autres nœuds workers, vous pouvez toujours suivre les mêmes étapes que celles expliquées ci-dessous pour rejoindre le cluster.
Tout d'abord, connectez-vous à votre nœud worker dans une session de terminal distincte. Vous utiliserez votre commande kubeadm join qui s'est affichée dans votre terminal lorsque nous avons initialisé le nœud maître à l' Étape 6. Exécutez la commande :
|
1 |
sudo kubeadm join 127.0.0.188:6443 --token u81y02.91gqwkxx6rnhnnly --discovery-token-ca-cert-hash sha256:4482ab1c66bf17992ea02c1ba580f4af9f3ad4cc37b24f189db34d6e3fe95c2d |
Vous devriez voir une sortie similaire à la capture d'écran ci-dessous lorsqu'il aura fini de rejoindre le cluster :
Une fois le processus de jonction terminé, basculez vers le terminal du nœud maître et exécutez la commande suivante pour confirmer que votre nœud worker a rejoint le cluster :
|
1 |
kubectl get nodes |
Dans la capture d'écran de la sortie de la commande ci-dessus, nous pouvons voir que le nœud worker a rejoint le cluster :
Étape 9 : Déploiement d'une application sur le cluster Kubernetes
À ce stade, vous avez configuré avec succès un cluster Kubernetes. Rendons le cluster utilisable en y déployant un service. Nginx is a popular web server boasting incredible speeds even with thousands of connections. Nous allons déployer le serveur web Nginx sur le cluster pour prouver que vous pouvez utiliser cette configuration dans une application réelle.
Exécutez la commande suivante sur le nœud maître pour créer un déploiement Kubernetes pour Nginx :
|
1 |
kubectl create deployment nginx --image=nginx |
Vous pouvez afficher le déploiement créé en utilisant la commande describe deployment :
|
1 |
kubectl describe deployment nginx |
Pour rendre le nginx service accessible via Internet, exécutez la commande suivante :
|
1 |
kubectl create service nodeport nginx --tcp=80:80 |
La commande ci-dessus créera un service public pour le déploiement Nginx. S'agissant d'un nodeport déploiement, Kubernetes attribue au service un port dans la plage de 32000+.
Vous pouvez obtenir les services actuels en exécutant la commande :
|
1 |
kubectl get svc |
Vous pouvez voir que notre port attribué est 32264. Prenez note du port affiché dans votre terminal pour l'utiliser à l'étape suivante.
Pour vérifier que le déploiement du service Nginx est réussi, effectuez un appel curl au nœud worker depuis le master. Remplacez l'adresse IP de votre nœud worker et le port que vous avez obtenu de la commande ci-dessus :
|
1 |
curl your-kubernetes-worker-ip:32264 |
Vous devriez voir la sortie du fichier par défaut d'Nginx index.html:
Optionnellement, vous pouvez visiter la combinaison de l'adresse IP et du port du nœud worker dans votre navigateur et afficher la page d'index par défaut d'Nginx :
Vous pouvez delete un déploiement en spécifiant le nom du déploiement. Par exemple, cette commande supprimera notre déploiement :
|
1 |
kubectl delete deployment nginx |
Nous avons maintenant testé notre cluster avec succès !
Conclusion
Dans ce tutoriel, vous avez appris à installer un cluster Kubernetes sur Ubuntu 20.04. Vous avez configuré un cluster composé d'un nœud master et d'un nœud worker. Vous avez pu installer l'ensemble d'outils Kubernetes, créer un réseau de pods et joindre le nœud worker au nœud master. Nous avons également testé notre concept en effectuant un déploiement de base d'un serveur web Nginx sur le cluster. Cela devrait servir de base pour travailler avec des clusters Kubernetes sur Ubuntu.
Bien que nous n'ayons utilisé qu'un seul nœud worker, vous pouvez étendre votre cluster avec autant de nœuds que vous le souhaitez. Si vous souhaitez approfondir le DevOps avec des outils d'automatisation comme Ansible, nous avons un tutoriel qui se penche sur le provisionnement de déploiements de clusters Kubernetes avec Ansible et Kubeadm, n'hésitez pas à le consulter. Si vous voulez apprendre comment déployer une application PHP sur un cluster Kubernetes, consultez ce tutoriel.
Bonne continuation !
Commentaires
Aucun commentaire pour l'instant. Soyez le premier.