Comment installer Kubernetes sur Ubuntu

Le déploiement manuel de conteneurs Docker sur plusieurs serveurs peut prendre beaucoup de temps et monopoliser l’emploi du temps de tout administrateur système chargé de cette tâche. Dans le secteur informatique moderne, la popularité des clouds, des microservices et des conteneurs ne cesse de croître, c’est pourquoi des solutions telles que Kubernetes ont été développées.Kubernetes est une solution open source de gestion et d’orchestration de conteneurs qui vous permet de créer un cluster afin de faciliter le déploiement de conteneurs dans des environnements distribués et d’assurer une haute disponibilité pour les applications conteneurisées. L’objectif de cet article est d’explorer comment installer Kubernetes sur Ubuntu pour exécuter des applications dans des conteneurs Docker.

NAKIVO for VMware vSphere Backup

Complete data protection for VMware vSphere VMs and instant recovery options. Secure backup targets onsite, offsite and in the cloud. Anti-ransomware features.

DISCOVER SOLUTION

Conditions à remplir pour installer Kubernetes sur Ubuntu

Le cluster Kubernetes se compose de nœuds maîtres et de nœuds de travail. La configuration matérielle dépend de vos besoins et des applications que vous prévoyez d’exécuter dans des conteneurs Docker. La configuration matérielle minimale requise pour installer Kubernetes sur Ubuntu est la suivante :

• Au moins un processeur x86/x64 à 2 cœurs (unité centrale de traitement)
• 2 Go de RAM (mémoire vive) ou plus
• accès à Internet

Ports qui doivent être ouverts pour installer Kubernetes sur Ubuntu :

Par défaut, le pare-feu iptables est installé sur Ubuntu, mais il n’y a pas de règles de blocage « prêtes à l’emploi ». Par conséquent, si vous installez Ubuntu pour essayer Kubernetes, vous n’avez pas besoin de modifier les règles du pare-feu. Kube-proxy place d’abord ses chaînes iptables, puis insère deux règles iptables. Ces règles sont KUBE-EXTERNAL-SERVICES et KUBE-FIREWALL, qui sont insérées en haut de la chaîne INPUT.L’installation de Kubernetes sur Ubuntu peut être effectuée à la fois sur des machines physiques et virtuelles. Il est généralement recommandé d’utiliser la dernière version de Ubuntu Linux 64 bits. L’article d’aujourd’hui explique comment installer Kubernetes sur Ubuntu 18.04 LTS fonctionnant sur des VMs VMware. Le premier type de déploiement Kubernetes expliqué est celui avec un nœud maître et deux nœuds de travail utilisés pour le cluster Kubernetes. Affichez le tableau ci-dessous pour connaître le nombre conditionnel de nœuds, les rôles des nœuds, les noms d’hôte et les adresses IP des machines utilisées dans l’exemple considéré.

Vous pouvez utiliser des VMs fonctionnant sur des hôtes VMware ESXi si vous utilisez VMware vSphere, ou vous pouvez exécuter des VMs sur VMware Workstation installé sur votre ordinateur personnel sous Linux ou Windows. Dans l’exemple d’aujourd’hui, nous utilisons des VMs fonctionnant sur VMware Workstation. Les VMs utilisent le NAT. réseau avec accès à Internet, et si vous préférez VirtualBox à VMware, vous pouvez l’utiliser.L’adresse IP de la machine hôte : 10.10.10.53Adresse IP de la passerelle virtuelle pour le réseau NAT (VMNet8) : 192.168.101.2Le même utilisateur Linux existe sur toutes les machines Ubuntu : utilisateur de KubernetesConfiguration VM : 2 processeurs, 4 Go de RAM, disque virtuel de 20 GoVous pouvez modifier les adresses IP du VMnet8 en vous rendant dans Edit > Virtual Network Editor dans VMware Workstation.Pour une meilleure compréhension, tous les composants seront installés manuellement sous Linux sans outils d’automatisation tels qu’Ansible dans l’exemple d’aujourd’hui.

Déploiement de la machine virtuelle Ubuntu

Créer une nouvelle VM nommée is docker-nakivo21.Installez Ubuntu 64 bits sur la première machine et définissez le nom d’hôte et le Nom d’utilisateur.VM-Name : docker-nakivo21Nom d’utilisateur: utilisateur de KubernetesInstallez VMware Tools après la première connexion au système d’exploitation installé. Si vous utilisez des machines physiques, vous n’avez pas besoin d’utiliser VMware Tools et pouvez ignorer cette étape.Remarque: Le $ Le caractère au début signifie qu’une commande est exécutée en tant qu’utilisateur normal (utilisateur de Kubernetes dans ce cas). Si la chaîne commence par le caractère # caractère, la commande doit être exécutée comme suit racine. Le sudo La commande (substitute user do ou super utilisateur do) vous permet d’exécuter des commandes en tant qu’autre utilisateur, y compris root. Vous pouvez taper sudo -i pour obtenir les privilèges root dans la console. Appuyez sur Ctrl+D pour quitter le mode root.Vous pouvez installer VMware Tools à partir de l’image ISO fournie avec l’hyperviseur VMware ou à partir des Référentiels Linux (expliqué ci-dessous).$ sudo apt-get install open-vm-toolsSi vous avez besoin d’une expérience de bureau avancée, telle que le presse-papiers partagé, le glisser-déposer & déposer des fichiers, etc., exécutez :$ sudo apt-get install open-vm-tools-desktopRedémarrez la machine virtuelle.$ init 6

Configurez votre machine Ubuntu avant d’installer Kubernetes

Certaines préparations doivent être effectuées avant d’installer Kubernetes sur des machines Ubuntu. Tout d’abord, vous devez configurer l’adresse IP statique et le nom d’hôte pour tout serveur habituel.

Définir l’adresse IP statique

Comme pour tout autre type de cluster, il est fortement recommandé d’utiliser des adresses IP statiques sur les nœuds.Installez les outils de mise en réseau Linux avant de définir l’adresse IP.$ sudo apt-get install net-toolsType ifconfig pour vérifier l’adresse IP actuelle de votre machine virtuelle Ubuntu.Vous pouvez voir que l’adresse IP est obtenue automatiquement via DHCP. Notez le nom de l’interface réseau. Dans l’exemple actuel, ce nom est ens33. Le nom de la première interface réseau Ethernet est généralement eth0 pour les machines physiques.Vous avez besoin d’un éditeur de texte pour modifier les fichiers de configuration. Installez vim comme éditeur de texte.$ sudo apt-get install vimDans les dernières versions d’Ubuntu, la configuration réseau est définie dans le fichier yaml. Ouvrez le fichier yaml de configuration réseau dans vim.$ sudo vim /etc/netplan/01-network-manager-all.yamlLa vue par défaut du fichier de configuration est :Modifiez ce fichier de configuration réseau comme indiqué ci-dessous :network: version: 2 renderer: networkd ethernets: ens33: dhcp4: no addresses: [192.168.101.21/24] gateway4: 192.168.101.2 nameservers: addresses: [192.168.101.2,8.8.8.8]Enregistrer les modifications et quitter.:wq$ sudo netplan tryAppuyez sur ENTRÉE pour accepter la nouvelle configuration.Vérifiez si votre configuration réseau a été modifiée et essayez d’envoyer une commande ping, par exemple, nakivo.com.$ ifconfig$ ping nakivo.com

Configurer un nom d’hôte

Vérifiez votre nom d’hôte actuel.$ hostnamectlComme vous vous en souvenez, le nom d’hôte de la première machine virtuelle qui est docker-nakivo21 a déjà été configuré lors de l’installation. Pour modifier le nom d’hôte, procédez comme suit (cela sera nécessaire pour configurer les deuxième et troisième VMs après le clonage. Ces deux VMs sont destinées à être configurées comme nœuds de travail) :Par exemple, si vous devez modifier le nom d’hôte en docker-nakivo21 Sur la première machine virtuelle, exécutez :$ sudo hostnamectl set-hostname docker-nakivo21Vérifiez qu’un nouveau nom d’hôte est appliqué.$ less /etc/hostnameModifier le hôtes fichier.$ sudo vim /etc/hostsLe contenu du fichier hôte doit ressembler à ceci :127.0.0.1 localhost127.0.1.1 docker-nakivo21Redémarrez la machine.$ init 6

Désactiver un fichier swap

L’utilisation d’un fichier swap (partition d’échange) n’est pas prise en charge par Kubernetes et il est nécessaire de désactiver la fonction swappiness pour installer Kubernetes sur Ubuntu avec succès.Désactivez un fichier swap pour éviter une utilisation élevée du processeur par kubelet.$ sudo swapoff -aModifier /etc/fstab et commentez la chaîne par la balise # caractère.$ sudo vim /etc/fstab#/swapfile Aucune swap sw 0 0Vous pouvez faire la même chose avec sed avec une seule commande :$ sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstabDésactiver le swap dans sysctl.conf$ sudo echo \"vm.swappiness=0\" | sudo tee --append /etc/sysctl.confOù 0 correspond au pourcentage de swapiness. Dans ce cas, le swap ne peut être utilisé que si vous êtes à court de RAM (par défaut, le swap est utilisé lorsque plus de 60 % de la RAM est pleine).Appliquez les modifications de configuration sans redémarrer.$ sudo sysctl -pRemarque: Si la partition d’échange n’est pas désactivée, le kswapd0 Le processus Ubuntu Linux exécutant Kubernetes peut consommer une grande quantité de ressources de processeur sur votre machine, ce qui peut entraîner un blocage des applications et du système. Cela se produit lorsque le système d’exploitation manque de mémoire et que les anciennes pages mémoire sont déplacées vers la mémoire swap par un processus système du noyau Linux. Pour des raisons étranges, il arrive parfois que des problèmes surviennent et qu’une boucle sans fin consommant toutes les ressources de processeur se produise. Sur la capture d’écran ci-dessous, vous pouvez voir une consommation de processeur élevée par le kswapd0 processus lorsque Kubernetes est installé sur Ubuntu. La valeur moyenne de charge est excessivement élevée.Si kswapd0 continue de surcharger votre processeur, exécutez la commande suivante pour invalider tous les caches mémoire et arrêter kswapd0 (exécuter en tant que root).# echo 1 > /proc/sys/vm/drop_cachesArrêtez la machine virtuelle.$ init 0Cette machine virtuelle partiellement configurée (docker-nakivo21) est sur le point d’être utilisé comme nœud maître. Créez deux machines qui serviront de nœuds de travail. Si vous utilisez des machines physiques, répétez manuellement les étapes précédentes (ou utilisez des outils d’automatisation tels qu’Ansible pour configurer simultanément plusieurs machines Linux via SSH). Comme des VMs sont utilisées dans l’exemple actuel, elles peuvent être clonées afin de gagner du temps lors de la préparation de l’environnement pour l’installation de Kubernetes sur des machines Ubuntu.

Cloner la VM

Clonez votre première machine virtuelle. Si vous utilisez VMware ESXi, vous pouvez utiliser la fonctionnalité de clonage intégrée. Pour en savoir plus à ce sujet, consultez notre article de blog par clonage de VMs par l’intermédiaire de modèles de VMs. Si vous utilisez VMware Workstation, vous pouvez également cloner des VMs par deux méthodes (outil de clonage intégré et manuellement). Vous pouvez cliquer sur VM > Manage > Clone pour créer un clone lié. Créons un clone complet de la première VM et copions manuellement les fichiers VM. Dans ce cas, les fichiers sont copiés à partir du docker-nakivo21 répertoire vers docker-nakivo31. Les répertoires doivent être créés manuellement avant de copier les fichiers VM.Modifiez le fichier VMX, car le VM-Name et le chemin d’accès au fichier du disque virtuel ont été modifiés.displayName = \"docker-nakivo31\"scsi0:0.fileName = \"C:\Virtual\KUBERNETES\docker-nakivo31\docker-nakivo31.vmdk\"nvram = \"docker-nakivo31.nvram\"La VM qui sera utilisée comme premier nœud de travail a maintenant été créée. Clonez à nouveau la première VM afin de préparer le deuxième nœud de travail du cluster Kubernetes.Modifiez le fichier VMX de la troisième VM (le deuxième nœud de travail), comme vous l’avez fait précédemment.displayName = \"docker-nakivo32\"scsi0:0.fileName = \"C:\Virtual\KUBERNETES\docker-nakivo31\docker-nakivo32.vmdk\"nvram = \"docker-nakivo32.nvram\"Ouvrez les clones de VM dans VMware Workstation (File> Open et sélectionnez le fichier VMX de la VM), ou double-cliquez simplement sur le fichier VMX de la VM. Allumez trois machines virtuelles (votre VM Source et deux clones de VM). Cliquez sur Je l’ai copié., lorsque vous y êtes invité.Remarque: Si vous utilisez des machines virtuelles, modifiez l’adresse IP et le nom d’hôte sur chaque clone de VM une fois que les VM ont été clonées. Si vous utilisez des machines physiques, suivez toutes les étapes précédentes en fonction des adresses IP et des noms d’hôte de chaque machine.

Configuration des adresses IP et des noms d’hôte sur les VMs

Modifier l’adresse IP et le nom d’hôte sur docker-nakivo31 et docker-nakivo32 VMs (comme indiqué ci-dessus).Répétez les étapes expliquées dans les sections ci-dessus pour configurer les adresses IP statiques et les noms d’hôte.L’adresse IP doit être : 192.168.101.31 et 192.168.101.32; les noms d’hôte doivent être docker-nakivo31 et docker-nakivo32 en conséquence sur les nœuds de travail.Toutes les machines doivent être configurées pour résoudre les noms d’hôte des nœuds en adresses IP. Vous pouvez configurer un serveur DNS ou modifier manuellement le fichier hôtes fichier sur chaque machine. Modifions hôtes.Ajoutez les chaînes suivantes au fichier hôtes fichier sur chaque machine (docker-nakivo21, docker-nakivo31, docker-nakivo32).$ sudo vim /etc/hostsAjoutez ces lignes au fichier hôtes fichier :192.168.101.21 docker-nakivo21192.168.101.31 docker-nakivo31192.168.101.32 docker-nakivo32Ping d’autres hôtes à partir de chaque hôte pour s’assurer que les noms d’hôtes sont résolus :$ ping docker-nakivo21$ ping docker-nakivo31$ ping docker-nakivo32

Configurer l’accès SSH sur tous les hôtes (VMs)

Configurez l’accès SSH sur tous les hôtes. Installez le serveur OpenSSH en exécutant les commandes sur chaque machine.$ sudo apt-get install openssh-serverAccédez au répertoire d’accueil de utilisateur de Kubernetes et générez la paire de clés SSH (un ensemble de clés cryptographiques composé d’une clé privée et d’une clé publique). Les paires de clés SSH peuvent être utilisées pour accéder à la console Linux distante via SSH sans utiliser de mots de passe. La clé publique peut être copiée sur une machine à partir de laquelle vous devez vous connecter à distance, tandis que la clé privée est hautement confidentielle et doit être stockée sur la machine à laquelle vous devez vous connecter.$ ssh-keygenIl n’est pas nécessaire de saisir le mot de passe pour générer la clé (le mot de passe est facultatif).Copiez les clés vers d’autres machines Ubuntu :$ ssh-copy-id kubernetes-user@192.168.101.31$ ssh-copy-id kubernetes-user@192.168.101.32Entrez votre mot de passe utilisateur pour confirmer la copie des clés.Essayez de vous connecter à la deuxième machine (docker-nakivo31) comme utilisateur de Kubernetes (c’est-à-dire un utilisateur régulier).$ ssh 'kubernetes-user@192.168.101.31'Testez ensuite la connexion à la troisième machine (docker-nakivo32).$ ssh 'kubernetes-user@192.168.101.32'Après la connexion, le nom de la machine distante s’affichera dans l’invite de commande de votre console.Appuyez sur Ctrl+D pour quitter la console distante.

Comment copier la clé pour se connecter via SSH en tant qu’utilisateur root ?

Comme vous aurez besoin des privilèges root dans Kubernetes, créons des clés pour configurer l’accès SSH pour root. Exécutez les commandes suivantes sur toutes les machines (docker-nakivo21, docker-nakivo31 et docker-nakivo32) auxquelles vous devez accéder via SSH en tant qu’utilisateur root.$ sudo -iModifiez le fichier de configuration du serveur SSH.# vim /etc/ssh/sshd_configAjoutez/modifiez la chaîne suivante dans ce fichier.PermitRootLogin yesRedémarrez le démon du serveur SSH.# /etc/init.d/ssh stop# /etc/init.d/ssh startDéfinissez le mot de passe root (mot de passe pour l’utilisateur root).# passwd$ cd /home/kubernetes-user/$ sudo ssh-keygen -t rsaCopiez la clé publique pour pouvoir vous connecter à distance via SSH en tant que utilisateur root (la clé est stockée dans le répertoire personnel de l’utilisateur standard, car la commande précédente a été exécutée à partir de ce répertoire).$ sudo ssh-copy-id -i /home/kubernetes-user/.ssh/id_rsa.pub 127.0.0.1Si votre clé est enregistrée dans le répertoire personnel de l’utilisateur root, copiez la clé à l’aide de cette commande :# ssh-copy-id -i /root/.ssh/id_rsa.pub 127.0.0.1Confirmez cette opération et entrez votre mot de passe.Répétez l’opération en copiant la clé de chaque machine vers les autres machines. Par exemple, sur le docker-nakivo21 exécution machine :# ssh-copy-id -i /root/.ssh/id_rsa.pub 192.168.101.31# ssh-copy-id -i /root/.ssh/id_rsa.pub 192.168.101.32Autorisez la clé publique.# cat /root/.ssh/id_rsa.pub >> /root/.ssh/authorized_keysÜberprüfen Sie, ob Sie sich als Administrator über SSH auf der lokalen Maschine anmelden können.$ sudo ssh root@127.0.0.1Essayez de vous connecter depuis/vers la machine distante sans entrer de mot de passe.$ sudo ssh root@192.168.101.21$ sudo ssh root@192.168.101.31$ sudo ssh root@192.168.101.32Remarque : La connexion en tant qu’utilisateur root peut ne pas être sécurisée. Ne vous connectez pas en tant que root si cela n’est pas nécessaire. Il est préférable de se connecter via SSH en tant qu’utilisateur standard et d’utiliser la commande sudo commande.

Installation de Docker

Docker est la plateforme de conteneurs d’applications d’entreprise la plus populaire prise en charge par Kubernetes. Installez Docker sur toutes les machines. Exécutez les commandes ci-dessous sur docker-nakivo21, docker-nakivo31, docker-nakivo32Cependant, il n’y a pas lieu de se précipiter. Pour un premier aperçu, vous pouvez simplement installer Docker en utilisant la commande habituelle :$ sudo apt-get install -y docker.ioCependant, dans ce cas, la version de Docker utilisée n’est peut-être pas la plus récente. Remédions à cela en installant la dernière version de Docker.Commencez par installer les paquets requis.$ sudo apt-get install apt-transport-https ca-certificates curl software-properties-commonCurl est un outil compact universel conçu pour transférer des données depuis/vers un hôte sans interaction de l’utilisateur par l’un des protocoles pris en charge (HTTP, HTTPS, FTP, FTPS, SFTP, LDAP, LDAPS, IMAP, IMAPS, POP3, POP3S, SCP, SMB, SMTP, TELNET, etc.).Ajoutez la clé GPG du référentiel Docker officiel à votre système Ubuntu :$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -La sortie de la console doit être OK.Ajoutez le référentiel officiel Docker à votre gestionnaire de paquets apt :$ sudo add-apt-repository \"deb [arch=amd64] https://download.docker.com/linux/ubuntu bionic stable\"Mettez à jour votre base de données du gestionnaire de paquets après avoir effectué des modifications manuelles par la commande précédente.$ sudo apt-get updateVérifiez la version du paquet Docker disponible dans le référentiel officiel.$ apt-cache policy docker-ceInstallez Docker.$ sudo apt-get install docker-ceVous pouvez vérifier la version de Docker après l’installation.$ docker --versionDans ce cas, le résultat est : Docker version 18.09.6, build 481bc77.Démarrez Docker et configurez son démon pour qu’il se charge automatiquement au démarrage du système.$ sudo systemctl start docker$ sudo systemctl enable dockerUne fois Docker installé sur toutes les machines, vous pouvez passer directement à l’étape d’installation de Kubernetes sur Ubuntu.

Installation de Kubernetes sur Ubuntu et initialisation du cluster

Désormais, rien ne vous empêche d’installer les composants principaux de Kubernetes.Exécutez les commandes en tant qu’administrateur sur toutes les machines à inclure dans le cluster Kubernetes.$ sudo -iAjoutez la clé GPG du référentiel officiel Docker à votre système Ubuntu :# curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add -Ajoutez le référentiel officiel Kubernetes à la base de données des référentiels de paquets disponibles pour votre gestionnaire de paquets apt.# cat </etc/apt/sources.list.d/kubernetes.listdeb http://apt.kubernetes.io/ kubernetes-xenial mainEOFVous pouvez également ajouter le référentiel à l’aide de la commande suivante :# echo 'deb http://apt.kubernetes.io/ kubernetes-xenial main' | sudo tee /etc/apt/sources.list.d/kubernetes.listOù tee est un outil qui lit l’entrée standard et écrit les données d’entrée dans la sortie standard et dans des fichiers définis.Mettez à jour la liste des paquets des référentiels disponibles sur votre système Ubuntu.# apt-get updateInstallation kubectl, kubeadm et kubectl Il est essentiel d’installer Kubernetes sur Ubuntu.# apt-get install -y kubelet kubeadm kubectlInstallez keepalived.# apt-get install keepalived# systemctl enable keepalived && systemctl start keepalivedÜberprüfen Sie, ob die Wert ist 1 pour la fonctionnalité de Kubernetes installé sur Ubuntu.# sysctl net.bridge.bridge-nf-call-iptablesPour définir cette valeur sur 1 exécutez la commande :sysctl net.bridge.bridge-nf-call-iptables=1Modifiez le fichier de configuration kubeadm.# vim /etc/systemd/system/kubelet.service.d/10-kubeadm.confAjoutez la chaîne après la chaîne Environment existante :Environment=”cgroup-driver=systemd/cgroup-driver=cgroupfs”Les cgroups sont des groupes de contrôle qui isolent l’utilisation des ressources telles que le processeur, la mémoire, les entrées/sorties disque et le réseau.Sur le nœud maître (docker-nakivo21) Exécutez la commande pour initialiser le cluster Kubernetes sur Ubuntu.# kubeadm init --pod-network-cidr=10.244.0.0/16 --apiserver-advertise-address=192.168.101.21Où–pod-network-cidr est requis par le pilote Flannel. Le CIDR (Classless Inter-Domain Routing) définit l’adresse de votre réseau superposé (tel que Flannel) qui sera configuré ultérieurement. Le masque réseau définit également le nombre de pods pouvant être exécutés par nœud. L’adresse réseau CIDR et l’adresse réseau utilisée pour Flannel doivent être identiques.–apiserver-advertise-address=192.168.101.21 définit l’adresse IP qui sera annoncée par Kubernetes comme son serveur API.Lisez les commandes de sortie et d’enregistrement affichées à la fin du texte. Ceci est un point important. Le jeton généré est nécessaire pour ajouter des nœuds de travail au cluster Kubernetes.Exécutez les commandes suivantes en tant qu’utilisateur ayant exécuté kubeadm initDans ce cas, les commandes sont exécutées en tant que root.# mkdir -p $HOME/.kube# sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config# sudo chown $(id -u):$(id -g) $HOME/.kube/configSi vous n’exécutez pas ces commandes, Kubernetes renverra l’erreur suivante : La connexion au serveur localhost:8080 a été refusée – avez-vous spécifié le bon hôte ou le bon port ?Kubernetes ne copie pas ceci config fichier dans le répertoire utilisateur automatiquement. Vous devez effectuer cette opération manuellement.Vérifiez les nœuds ajoutés au cluster# kubectl get nodesVous pouvez voir un nœud maître qui possède le NotReady Statut dans le cluster Kubernetes qui est en cours d’installation sur Ubuntu. Cela est dû au fait que le réseau superposé n’a pas été configuré. Configurez Flannel afin de corriger le NotReady statut du nœud maître Kubernetes. Créez le répertoire pour stocker les fichiers yaml pour Docker et Kunernetes, par exemple /home/kubernetes-user/kubernetes/YAML (Yet Another Markup Language) vous offre plus de commodité lors de la création de pods et de déploiements dans Kubernetes. Vous pouvez définir tous les paramètres des conteneurs qui doivent être déployés dans le fichier de configuration YAML au lieu d’exécuter chaque commande manuellement dans la console Linux. Les fichiers YAML sont également appelés fichiers manifestes dans le contexte de Kubernetes.Créez le fichier de configuration yaml avec le contenu suivant :kube-flannel.ymlExécutez la commande# kubectl apply -f ./kube-flannel.ymlVous pouvez également trouver des exemples gratuits de configurations de déploiement YAML pour Kubernetes sur GitHub.kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/a70459be0084506e4ec919aa1c114638878db11b/Documentation/kube-flannel.ymlVérifiez les nœuds ajoutés au cluster Kubernetes que vous effectuez sur Ubuntu :# kubectl get nodesLe statut du nœud maître est désormais Prêt.Assurez-vous que Flannel a été correctement configuré :# kubectl get pods --all-namespacesVous pouvez voir que le pod Flannel est en cours d’exécution. Ce pod se compose de deux conteneurs : le démon Flannel et initContainer, utilisé pour le déploiement de la configuration CNI à un emplacement lisible par Kubernetes.Parfois, lorsque vous installez Kubernetes sur Ubuntu, l’erreur suivante peut se produire :Impossible de se connecter au serveur : net/http : délai d’attente de la négociation TLS expiré.Comment résoudre ce problème ? Attendez quelques secondes et réessayez, cela suffit souvent.Les espaces de noms sont des entités logiques dans le cluster Kubernetes qui représentent les ressources du cluster et peuvent être considérés comme des clusters virtuels. Un cluster physique peut être divisé logiquement en plusieurs clusters virtuels. Les espaces de noms Kubernetes par défaut sont Par défaut, Kube-public, et Système KubeVous pouvez obtenir la liste des espaces de noms :# kubectl get namespacesComme vous vous en souvenez, l’unité de déploiement de base dans Kubernetes est un pod, qui est un ensemble de conteneurs partageant le même réseau et le même espace de noms de montage. Tous les conteneurs du pod sont planifiés sur le même nœud Kubernetes. Vérifiez les pods disponibles :# kubectl -n kube-system get podsSi vous souhaitez réinitialiser/arrêter le cluster, exécutez :# kubeadm resetTout est OK sur le nœud maître. Cela signifie que vous pouvez maintenant continuer à installer Kubernetes sur Ubuntu et passer à l’ajout de nœuds de travail au cluster.Sur les nœuds de travail (docker-nakivo31, docker-nakivo32) exécutez la commande :# kubeadm join 192.168.101.21:6443 --token d8mbzb.uulxu01jbty8yh4z \ --discovery-token-ca-cert-hash sha256:65ace7a4ff6fff795abf086f18d5f0d97da71d4639a0d0a6b93f42bea4948a79Le jeton et le hachage ont été notés après l’initialisation du cluster avec le kubeadm init commande, comme vous vous en souvenez peut-être.Sur le nœud maître, vérifiez à nouveau le statut du cluster.# kubectl get nodesVous pouvez désormais voir un nœud maître et deux nœuds esclaves dans le cluster Kubernetes fonctionnant sur des machines Ubuntu.Vous pouvez vérifier la configuration de Kubernetes :# kubectl cluster-info

Déploiement d’un pod dans Kubernetes

Vous pouvez désormais réaliser le déploiement d’un pod avec des conteneurs dans votre cluster Kubernetes. Comme vous vous en souvenez, les conteneurs sont inclus dans les pods dans Kubernetes. Si vous utilisez des fichiers yaml, créez un répertoire pour stocker ces fichiers afin de faciliter leur utilisation. Accédez à ce répertoire et exécutez les commandes suivantes : kubectl apply -f test.yamlUn tel répertoire a déjà été créé lors de la configuration de Flannel – /home/kubernetes-user/kubernetes/Il est temps de déployer un nouveau pod. Vous devez d’abord créer un déploiement. Le déploiement est un concept de contrôleur utilisé pour fournir des mises à jour déclaratives aux pods et aux ensembles de répliques. Vous pouvez créer un déploiement à l’aide d’une seule commande ou par l’intermédiaire de fichiers yaml.

Exemple 1 – déploiement de MySQL

Créons un fichier yaml dans cet exemple. Le nom du fichier est mysql-déploiement.yamlConsultez la pièce jointe pour afficher la configuration.# vim mysql-deployment.yamlIl existe deux approches courantes pour la gestion des ressources avec kubectlQuelle est la différence entre kubectl create et kubectl apply? Lors de l’utilisation kubectl create, vous indiquez à Kubernetes ce que vous souhaitez créer, remplacer ou supprimer ; cette commande écrase toutes les modifications. Vous pouvez également utiliser kubectl apply apporte des modifications incrémentielles et cette commande peut être utilisée pour enregistrer les modifications appliquées à un objet actif.Créer un déploiement :# kubectl apply -f ./mysql-deployment.yamlKubernetes peut afficher des informations sur votre déploiement.# kubectl describe deployment mysqlConsultez les pods :# kubectl get poou# kubectl get podsou# kubectl get pods -l app=mysqlSi vous voyez le statut « en attente » pour le pod, cela peut signifier que les ressources informatiques sont insuffisantes. Essayez d’ajouter de la capacité pour les processeurs et la mémoire pour corriger le statut « en attente » du pod dans Kubernetes.Vous pouvez supprimer le service si nécessaire :# kubectl delete service Vous pouvez également supprimer un pod :# kubectl delete pod mysql-7b9b7999d8-nz5tm

Exemple 2 – Déploiement de nginx

Déployons nginx par une autre méthode sans fichiers yaml.Créons un déploiement.# kubectl create deployment nginx --image=nginxVérifiez que le déploiement a bien été créé.# kubectl get deploymentsCréer un service.# kubectl create service nodeport nginx --tcp=80:80Un service peut être créé par l’utilisation des types de service suivants : ClusterIP, NodePort, LoadBalance et ExternalName. Si le type NodePort est utilisé, un port aléatoire compris dans la gamme 30000-32767 est attribué pour accéder aux services fournis. Le trafic envoyé à ce port est transféré vers le service nécessaire.Vérifiez que le service est créé et qu’il écoute sur le port défini.# kubectl get svcMémorisez le numéro du port (31453 dans ce cas).Vérifiez si votre service est déployé et disponible (la commande est exécutée sur le nœud maître dans cet exemple). Utilisez le nom d’hôte du nœud et le port que vous avez mémorisés à l’étape précédente.# curl docker-nakivo31:31453Vous pouvez également vérifier que le service est accessible dans le navigateur de n’importe quel nœud. Dans la barre d’adresse du navigateur Web, essayez de visiter les pages suivantes :http:// 10.101.235.90ouhttp://docker-nakivo31:31453http://docker-nakivo32:31453Si tout est OK, vous verrez la page d’accueil de nginx.Il est également possible de consulter la page de test nginx depuis n’importe quel ordinateur ayant accès au réseau auquel les nœuds Kubernetes sont connectés—(192.168.101.0/24) dans ce cas. Par exemple, vous pouvez visiter les pages Web avec votre navigateur :http://192.168.101.21:31453/http://192.168.101.31:31453/http://192.168.101.32:31453/

Configurer l’interface Web pour la surveillance de Kubernetes

L’installation de Kubernetes sur Ubuntu est presque terminée, mais vous pouvez également installer le tableau de bord Kubernetes pour plus de commodité. Le tableau de bord Kubernetes est une interface web permettant de gérer et de réaliser la surveillance de Kubernetes. Pour installer le tableau de bord, créez le fichier kubernetes-tableau de bord.yaml fichier, comme vous l’avez fait précédemment avant d’exécuter les commandes.# kubectl create -f ./kubernetes-dashboard.yaml# kubectl apply -f ./kubernetes-dashboard.yamlVérifiez les pods.# kubectl get pods -o wide --all-namespacesDémarrez le proxy vers le serveur API Kubernetes.# kubectl proxyPour entrer les commandes suivantes dans la console, veuillez ouvrir une autre fenêtre de console. Sinon, le processus serait interrompu.Dans votre navigateur Web sur le nœud maître, accédez à la page :http://localhost:8001Vous pouvez voir la page de test.Entrez l’adresse complète dans la barre d’adresse du navigateur Web.http://localhost:8001/api/v1/namespaces/kube-system/services/https:kubernetes-dashboard:/proxy/Créez un tableau de bord avec un compte de service en exécutant les commandes dans la nouvelle fenêtre de console.# kubectl create serviceaccount dashboard -n default# kubectl create clusterrolebinding dashboard-admin -n default \ --clusterrole=cluster-admin \ --serviceaccount=default:dashboard# kubectl get secret $(kubectl get serviceaccount dashboard -o jsonpath=\"{.secrets[0].name}\") -o jsonpath=\"{.data.token}\" | base64 –decodeVous pouvez maintenant voir le jeton généré :Copiez le jeton généré et collez-le dans la section « jeton » de l’interface Web pour vous connecter au tableau de bord.Sur la capture d’écran ci-dessous, vous pouvez voir l’interface Web du tableau de bord Kubernetes. Vous pouvez voir le statut des nœuds, des déploiements et des pods, ainsi que vérifier les rôles, les classes de stockage et d’autres composants.

Configurer Heapster, l’outil de surveillance

Installez Heapster pour étendre les options de surveillance du tableau de bord Kubernetes en ajoutant des paramètres de surveillance du processeur, de la mémoire et autres. Créez un fichier manifeste dont le nom est heapster.yaml.# vim heapster.yamlDans l’action suivante, effectuez le déploiement de Heapster.# kubectl create -f heapster.yamlModifiez le rôle RBAC (Contrôle d’accès basé sur les rôles) de Heapster et ajoutez des autorisations pour accéder aux statistiques des nœuds.# kubectl edit clusterrole system:heapsterVérifiez que les métriques du processeur et de la mémoire peuvent être mesurées dans la console.# kubectl top nodeVous pouvez désormais ouvrir l’interface Web du tableau de bord Kubernetes et constater que certaines sections, notamment les graphiques d’utilisation du processeur et de la mémoire, ont été ajoutées.Votre cluster Kubernetes est désormais configuré et prêt à fonctionner.

Déploiement d’un cluster Kubernetes haute disponibilité avec plusieurs maîtres sur Ubuntu

Disposer d’un cluster Kubernetes avec un nœud maître et plusieurs nœuds de travail est une bonne option, mais il arrive parfois que le seul nœud maître tombe en panne pour des raisons telles que des problèmes matériels ou une coupure de courant. Pour une meilleure tolérance aux pannes du cluster Kubernetes déployé sur des nœuds Ubuntu, il est préférable d’envisager le déploiement d’un cluster Kubernetes haute disponibilité avec plusieurs nœuds maîtres. L’utilisation de ce modèle de déploiement de cluster Kubernetes vous permet d’éviter un point de défaillance unique. Il est recommandé d’utiliser un nombre impair de nœuds maîtres, le nombre minimum de nœuds maîtres pouvant assurer la tolérance aux pannes étant de trois. Si vous utilisez plus de trois nœuds maîtres et que le nombre de nœuds est pair, la tolérance aux pannes de l’ensemble du cluster n’augmente pas. Consultez le tableau ci-dessous pour comparer la valeur de la tolérance aux pannes en fonction du nombre de nœuds maîtres dans le cluster Kubernetes. Par exemple, si vous disposez d’un cluster avec 5 nœuds maîtres, le cluster peut survivre à une défaillance de 2 nœuds maîtres, car trois nœuds maîtres continuent d’arborer un état de fonctionnement (3 sur 5, soit plus de 50 %, ce qui représente la majorité). La taille du cluster fait référence au nombre de nœuds maîtres dans le cluster.

Cette section du billet de blog d’aujourd’hui explique comment installer Kubernetes sur des nœuds Ubuntu dans le cadre du déploiement d’un cluster Kubernetes haute disponibilité, d’un proxy HA et de certains nœuds de travail. Le tableau ci-dessous présente les adresses IP, les noms d’hôte et les rôles des hôtes utilisés pour installer le cluster Kubernetes HA sur des nœuds Ubuntu dans le laboratoire de test décrit dans cet exemple.

Certaines commandes sont identiques à celles utilisées pour installer Kubernetes sur Ubuntu par le modèle à nœud maître unique. C’est la raison pour laquelle les commentaires relatifs à certaines commandes ne sont pas répétés. Vous pouvez faire défiler cette page vers le haut pour rappeler l’explication des commandes.Préparez toutes les machines (proxy HA, nœuds maîtres et nœuds de travail) pour l’installation de Kubernetes en procédant comme suit :

• Configurer les adresses IP statiques.
• Définissez les noms d’hôtes. Les noms de tous les hôtes doivent être résolus en adresses IP.
• L’accès SSH doit être activé et configuré par l’intermédiaire de certificats.
• Le swap doit être désactivé.

Ces étapes doivent être effectuées avant de commencer l’installation de Docker sur chaque machine, comme expliqué dans la section ci-dessus lors de l’installation de Kubernetes sur Ubuntu par l’intermédiaire d’un nœud maître. Une fois toutes les machines préparées, rendez-vous sur (192.168.101.19).

Configuration du répartiteur de charge HA Proxy

Le répartiteur de charge HA Proxy est utilisé pour répartir le trafic entrant entre les nœuds Kubernetes. Le répartiteur de charge est déployé devant les nœuds maîtres. Ouvrez la console du ha-proxy19 machine, puis effectuez les actions indiquées ci-dessous.

Installer cfssl

Cfssl (Cloud Flare SSL) est une boîte à outils utilisée pour générer différents certificats, notamment des chaînes de certificats TLS/SSL.Téléchargez les binaires depuis le référentiel officiel.# wget https://pkg.cfssl.org/R1.2/cfssl_linux-amd64# wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64Rendez les fichiers binaires téléchargés exécutables.# chmod +x cfssl*Déplacez ces fichiers binaires vers /usr/local/bin/# mv cfssl_linux-amd64 /usr/local/bin/cfssl# mv cfssljson_linux-amd64 /usr/local/bin/cfssljsonÜberprüfen Sie die Installation, indem Sie die Version des installierten cfssl-Browsers überprüfen.# cfssl versionMettre à jour l’arborescence du référentiel.# apt-get updateInstallez HA proxy.# apt-get install haproxyCréer et modifier le haproxy.cfg fichier.# vim /etc/haproxy/haproxy.cfgAjoutez ces lignes à la fin de ce fichier de configuration.frontend kubernetesbind 192.168.101.19:6443option tcplogmode tcpdefault_backend kubernetes-master-nodesbackend kubernetes-master-nodesmode tcpbalance roundrobinoption tcp-checkserver docker-nakivo21 192.168.101.21:6443 check fall 3 rise 2server docker-nakivo22 192.168.101.22:6443 check fall 3 rise 2server docker-nakivo23 192.168.101.23:6443 check fall 3 rise 2Redémarrez le service.# systemctl restart haproxy

Générer des certificats TSL

Vous pouvez continuer à utiliser la console de la machine proxy HA. Créez le fichier de configuration de l’autorité de certification, qui est nommé ca-config.json.# vim ca-config.jsonAjoutez le contenu suivant à ce fichier de configuration :{ \"signing\": { \"default\": { \"expiry\": \"8760h\" }, \"profiles\": { \"kubernetes\": { \"usages\": [\"signing\", \"key encipherment\", \"server auth\", \"client auth\"], \"expiry\": \"8760h\" } } }}Créer le fichier de configuration de la demande de signature de l’autorité de certification.# vim ca-csr.jsonAjoutez le contenu à ce fichier comme indiqué ci-dessous :{ « CN »: « Kubernetes », « key »: { « algo »: « rsa », « taille »: 2048 }, « names »: [ { « C »: « GB », « L »: « London », « O »: « Kubernetes », « OU »: « CA », « ST »: « Nakivo » } ]}Où :C – pays, par exemple GB (Grande-Bretagne).L – emplacement tel que ville ou village.O – organisation.OU – unité organisationnelle (par exemple, un service défini comme détenteur de clés).ST – l’État ou la province.Générez maintenant la clé publique et la clé privée.# cfssl gencert -initca ca-csr.json | cfssljson -bare caÜberprüfen, dass der ca-key.pem et le ca.pem Les clés ont été générées.# ls -al

Création du certificat pour le cluster Etcd

Etcd prend en charge la communication entre serveurs/clusters par authentification par certificats clients. Vous devez disposer d’un certificat CA et d’une paire de clés signées pour un membre du cluster.Créez le fichier de configuration de la demande de signature de certificat.# vim kubernetes-csr.json{ \"CN\": \"kubernetes\", \"key\": { \"algo\": \"rsa\", \"size\": 2048 }, \"names\": [ { \"C\": \"GB\", \"L\": \"London\", \"O\": \"Kubernetes\", \"OU\": \"Kubernetes\", \"ST\": \"Nakivo\" } ]}Après, générez le certificat et la clé privée.# cfssl gencert \-ca=ca.pem \-ca-key=ca-key.pem \-config=ca-config.json \-hostname=192.168.101.21,192.168.101.22,192.168.101.23,192.168.101.19,127.0.0.1,kubernetes.default \-profile=kubernetes kubernetes-csr.json | \cfssljson -bare kubernetesRépertoriez les fichiers dans votre répertoire um zu überprüfen, dass es sie gibt kubernetes-key.pem et le kubernetes.pem Le fichier a été généré.# ls -alCopiez le certificat créé sur chaque nœud.# scp ca.pem kubernetes.pem kubernetes-key.pem kubernetes-user@192.168.101.21:~# scp ca.pem kubernetes.pem kubernetes-key.pem kubernetes-user@192.168.101.22:~# scp ca.pem kubernetes.pem kubernetes-key.pem kubernetes-user@192.168.101.23:~# scp ca.pem kubernetes.pem kubernetes-key.pem kubernetes-user@192.168.101.31:~# scp ca.pem kubernetes.pem kubernetes-key.pem kubernetes-user@192.168.101.32:~# scp ca.pem kubernetes.pem kubernetes-key.pem kubernetes-user@192.168.101.33:~Où ~ est un répertoire personnel de utilisateur de Kubernetes sur les hôtes Ubuntu.

Préparation des nœuds Ubuntu pour l’installation de Kubernetes

Exécutez les commandes indiquées dans cette section sur tous les nœuds maîtres et nœuds de travail. Installez Docker, puis installez Kubernetes sur les machines Ubuntu qui seront incluses dans le cluster Kubernetes. Commençons par préparer le 192.168.101.21 nœud maître.Installez Docker.# apt-get install apt-transport-https ca-certificates curl software-properties-common# curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -# add-apt-repository \"deb [arch=amd64] https://download.docker.com/linux/ubuntu bionic stable\"# apt-get update# apt-get install docker-ceDocker est maintenant installé. Cubeadm, kublet et cubectl sont les composants Kubernetes nécessaires pour installer Kubernetes sur Ubuntu.Installez les composants Kubernetes : kubeadm, kublet et kubectl.# curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add -# echo 'deb http://apt.kubernetes.io/ kubernetes-xenial main' | sudo tee /etc/apt/sources.list.d/kubernetes.list# apt-get update# apt-get install -y kubelet kubeadm kubectlUne fois que vous avez préparé tous les nœuds et installé Docker, kubelet, kubeadm et kubectl, vous devez installer et configurer etcd sur les nœuds maîtres.

Installation et configuration d’etcd sur les nœuds maîtres Ubuntu

Etcd est un magasin cohérent et hautement disponible, destiné à stocker des clés et à sauvergarder toutes les données du cluster. Le cluster etcd doit être configuré avant de configurer le cluster Kubernetes HA avec plusieurs nœuds maîtres. Commençons par configurer le 192.168.101.21 nœud maître.Installing and configuring etcd on the 192.168.101.21 machineCréer un répertoire de configuration pour etcd.# mkdir /etc/etcd /var/lib/etcdAccédez au répertoire dans lequel les certificats ont été copiés. Il s’agit du répertoire d’accueil de l’utilisateur kubernetes, dans ce cas : /home/kubernetes-user/Copiez les certificats dans le répertoire de configuration etcd.# cp ca.pem kubernetes.pem kubernetes-key.pem /etc/etcdÜberprüfen Sie, dass die Dateien kopiert wurden.# ls -al /etc/etcdRetournez à votre répertoire précédent# cd -Téléchargez les binaires etcd depuis le référentiel.# wget https://github.com/coreos/etcd/releases/download/v3.3.9/etcd-v3.3.9-linux-amd64.tar.gzExtrayez l’archive etcd.# tar xvzf etcd-v3.3.9-linux-amd64.tar.gzDéplacez maintenant les fichiers binaires etcd vers /usr/local/bin/# mv etcd-v3.3.9-linux-amd64/etcd* /usr/local/bin/Créer un fichier d’unité systemd etcd.# vim /etc/systemd/system/etcd.serviceAjoutez les chaînes ci-dessous à ce fichier.[Unit]Description=etcdDocumentation=https://github.com/coreos[Service]ExecStart=/usr/local/bin/etcd \ --name 192.168.101.21 \ --cert-file=/etc/etcd/kubernetes.pem \ --key-file=/etc/etcd/kubernetes-key.pem \ --peer-cert-file=/etc/etcd/kubernetes.pem \ --peer-key-file=/etc/etcd/kubernetes-key.pem \ --trusted-ca-file=/etc/etcd/ca.pem \ --peer-trusted-ca-file=/etc/etcd/ca.pem \ --peer-client-cert-auth \ --client-cert-auth \ --initial-advertise-peer-urls https://192.168.101.21:2380 \ --listen-peer-urls https://192.168.101.21:2380 \ --listen-client-urls https://192.168.101.21:2379,http://127.0.0.1:2379 \ --advertise-client-urls https://192.168.101.21:2379 \ --initial-cluster-token etcd-cluster-0 \ --initial-cluster 192.168.101.21=https://192.168.101.21:2380,192.168.101.22=https://192.168.101.22:2380,192.168.101.23=https://192.168.101.23:2380 \ --initial-cluster-state new \ --data-dir=/var/lib/etcdRestart=on-failureRestartSec=5[Install]WantedBy=multi-user.targetRechargez la configuration du gestionnaire systemd pour récupérer les configurations modifiées dans le système de fichiers et régénérer les arborescences de dépendances.# systemctl daemon-reloadLancer etcd au démarrage.# systemctl enable etcdDémarrer etcd.# systemctl start etcdEffectuez les mêmes actions sur le deuxième nœud maître (docker-nakivo22 – 192.168.101.21 et docker-nakivo23 – 192.168.101.22). La seule différence dans les actions requises pour ces nœuds maîtres réside dans la modification du fichier etcd.service fichier de configuration. Définissez les adresses IP correctes pour chaque autre nœud maître. Par exemple, le etcd.service Le fichier de configuration doit être le suivant pour le deuxième nœud maître (192.168.101.22) du laboratoire de test Kubernetes actuel.[Unit]Description=etcdDocumentation=https://github.com/coreos[Service]ExecStart=/usr/local/bin/etcd \ --name 192.168.101.22 \ --cert-file=/etc/etcd/kubernetes.pem \ --key-file=/etc/etcd/kubernetes-key.pem \ --peer-cert-file=/etc/etcd/kubernetes.pem \ --peer-key-file=/etc/etcd/kubernetes-key.pem \ --trusted-ca-file=/etc/etcd/ca.pem \ --peer-trusted-ca-file=/etc/etcd/ca.pem \ --peer-client-cert-auth \ --client-cert-auth \ --initial-advertise-peer-urls https://192.168.101.22:2380 \ --listen-peer-urls https://192.168.101.22:2380 \ --listen-client-urls https://192.168.101.22:2379,http://127.0.0.1:2379 \ --advertise-client-urls https://192.168.101.22:2379 \ --initial-cluster-token etcd-cluster-0 \ --initial-cluster 192.168.101.21=https://192.168.101.21:2380,192.168.101.22=https://192.168.101.22:2380,192.168.101.23=https://192.168.101.23:2380 \ --initial-cluster-state new \ --data-dir=/var/lib/etcdRestart=on-failureRestartSec=5[Install]WantedBy=multi-user.target

Initialisation des nœuds maîtres dans le cluster HA Kubernetes

Vous pouvez désormais initialiser les nœuds maîtres dans votre cluster Kubernetes HA installé sur des machines Ubuntu.

Initialisation du nœud maître 192.168.101.21

Sur le premier nœud maître, effectuez les opérations décrites ci-dessous.Créez le fichier de configuration yaml pour kubeadm.# vim config.yamlAjoutez les paramètres de configuration à ce fichier :apiVersion: kubeadm.k8s.io/v1alpha3kind: ClusterConfigurationkubernetesVersion: stableapiServerCertSANs:- 192.168.101.19controlPlaneEndpoint: \"192.168.101.19:6443\"etcd: external: endpoints: - https://192.168.101.21:2379 - https://192.168.101.22:2379 - https://192.168.101.23:2379 caFile: /etc/etcd/ca.pem certFile: /etc/etcd/kubernetes.pem keyFile: /etc/etcd/kubernetes-key.pemnetworking: podSubnet: 10.244.0.0/16apiServerExtraArgs: apiserver-count: \"3\"Le réseau défini comme podSubnet (10.244.0.0/16) doit être identique à celui du kube-flannel.yml fichier.Initialisez la machine Ubuntu en tant que nœud maître.# kubeadm init --config=config.yamlParfois, vous pouvez voir un avertissement concernant l’ancienne version d’un fichier de configuration :Votre fichier de configuration utilise une spécification API obsolète : « kubeadm.k8s.io/v1alpha3 ». Veuillez utiliser « kubeadm config migrate –old-config old.yaml –new-config new.yaml », qui écrira la nouvelle spécification similaire en utilisant une version API plus récente.Mettez à jour la version du fichier de configuration à l’aide de la commande :# kubeadm config migrate --old-config config.yaml --new-config config1.yamlUne autre erreur peut se produire lorsque vous initialisez un nœud d’un cluster Kubernetes multi-maître si etcd n’est pas en cours d’exécution :[ERROR ExternalEtcdVersion]: Obtenir l’https://192.168.101.21:2379/version : composer tcp 192.168.101.21:2379 : connecter : connexion refuséeVérifiez si votre etcd est en cours d’exécution. Vous pouvez exécuter etcd manuellement :# systemctl start etcdAprès l’initialisation réussie du nœud maître dans le cluster Kubernetes fonctionnant sous Ubuntu, vous obtenez le message suivant, tel qu’affiché sur la capture d’écran.Le résultat de l’exécution réussie de cette commande contient un conseil sur la manière de commencer à utiliser votre cluster, ainsi que des commandes contenant un jeton et un hachage de certificat nécessaires pour joindre des nœuds au cluster. Enregistrez ces chaînes importantes, car vous en aurez besoin prochainement. Elles sont marquées en jaune sur la capture d’écran et sont reproduites ci-dessous.Vous pouvez désormais rejoindre un nombre illimité de nœuds de plan de contrôle en copiant les autorités de certification. et les clés du compte de service sur chaque nœud, puis en exécutant la commande suivante en tant qu’administrateur :kubeadm join 192.168.101.19:6443 --token sxm34y.p4rn4328vne0iihf \ --discovery-token-ca-cert-hash sha256:bf3887f1565fcd48ff696da98a761ac1b70c6d38ba0ba3e4b1bf573000a302ca \ --experimental-control-planeVous pouvez ensuite rejoindre autant de nœuds de travail que vous le souhaitez en exécutant la commande suivante sur chacun d’entre eux en tant qu’administrateur :kubeadm join 192.168.101.19:6443 --token sxm34y.p4rn4328vne0iihf \ --discovery-token-ca-cert-hash sha256:bf3887f1565fcd48ff696da98a761ac1b70c6d38ba0ba3e4b1bf573000a302caExécutez les commandes pour commencer à utiliser le nœud initialisé dans le cluster.# mkdir -p $HOME/.kube# sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config# sudo chown $(id -u):$(id -g) $HOME/.kube/configVérifiez les nœuds ajoutés au cluster.# kubectl get nodesCopiez les certificats vers les deux autres nœuds maîtres# scp -r /etc/kubernetes/pki kubernetes-user@192.168.101.22:~# scp -r /etc/kubernetes/pki kubernetes-user@192.168.101.23:~

Initialisation du nœud maître 192.168.101.22

Exécutez les commandes sur le deuxième nœud maître (192.168.101.22).Enlevez le apiserver.crt et apiserver.key qui se trouvent dans le répertoire d’accueil (~) du utilisateur de Kubernetes.$ rm ~/pki/apiserver.*Déplacez les certificats stockés dans le répertoire d’accueil vers le répertoire /etc/kubernetes/ répertoire.$ sudo mv ~/pki /etc/kubernetes/Créez le fichier de configuration YAML pour kubeadm.# vim config.yamlLe contenu de ce fichier yaml est identique à celui du premier nœud maître (192.168.101.21). Reportez-vous à la configuration pour l’initialisation du premier nœud maître ci-dessus. Vous pouvez copier le fichier déjà créé utilisé sur le premier nœud maître du cluster Kubernetes HA installé sur vos machines Ubuntu.Initialisez le deuxième nœud maître.# kubeadm config migrate --old-config config.yaml --new-config config1.yaml# kubeadm init --config=config1.yamlLa sortie est identique à celle qui s’est affichée après la première initialisation du nœud maître dans le cluster HA Kubernetes :De même, exécutez les commandes pour commencer à utiliser le nœud initialisé dans le cluster.# mkdir -p $HOME/.kube# sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config# sudo chown $(id -u):$(id -g) $HOME/.kube/configVérifiez les nœuds ajoutés au cluster.# kubectl get nodesDeux nœuds maîtres sur trois ont été ajoutés au cluster. Il reste un nœud maître à ajouter.

Initialisation du troisième nœud maître (192.168.101.23)

Répétez les mêmes étapes que celles effectuées pour initialiser le deuxième nœud (192.168.101.22) dans le cluster.N’oubliez pas de noter les commandes avec les jetons et les hachages pour ajouter des nœuds au cluster qui s’affichent après l’initialisation du nœud maître.Vérifiez que les trois nœuds maîtres ont bien été ajoutés au cluster.# kubectl get nodes

Installation de Flannel pour corriger le statut NotReady des nœuds maîtres dans Kubernetes

Installons Flannel. Contrairement au premier exemple où vous avez appris à installer Kubernetes sur Ubuntu pour créer un cluster maître unique, dans cet exemple, Flannel sera installé par le fichier yaml.Exécutez la commande pour installer Flannel et corriger le NotReady statut des nœuds qui s’affiche, car aucun réseau superposé n’est encore configuré. Créez le kube-flannel.yaml Fichier avec l’éditeur de texte vim, par exemple, sur le premier nœud maître.# kubectl apply -f kube-flannel.ymlSouvenez-vous de l’adresse du podSubnet définie dans le config.yaml fichier. L’adresse réseau doit être la même dans le kube-flannel.yaml fichier.Vérifiez vos nœuds et leur statut.# kubectl get nodesMaintenant, tous les nœuds maîtres fonctionnent correctement.

Ajout de nœuds de travail au cluster

Une fois tous les nœuds maîtres initialisés, vous pouvez ajouter des nœuds de travail à votre cluster Kubernetes. Ajoutons le premier nœud de travail (192.168.101.31) au cluster HA Kubernetes déployé sur les machines Ubuntu. Utilisez la commande qui s’est affichée après l’initialisation des nœuds maîtres (la commande qui contient le jeton et le hachage) pour faire rejoindre le cluster au nœud de travail. Exécutez la commande sur le 192.168.101.31 machine.# kubeadm join 192.168.101.19:6443 --token kxl1gf.6ddalutd60n0ez45 \ --discovery-token-ca-cert-hash sha256:bf3887f1565fcd48ff696da98a761ac1b70c6d38ba0ba3e4b1bf573000a302caVérifiez les nœuds du cluster HA Kubernetes pour vous assurer que le nœud de travail a bien été ajouté. Vous pouvez également voir la machine proxy HA dans la liste des nœuds.# kubectl get nodesDe même, ajoutez d’autres nœuds de travail au cluster Kubernetes haute disponibilité installé sur les machines Ubuntu. Vous pouvez ajouter d’autres nœuds de travail à tout moment en fonction de vos besoins. À ce stade, le tutoriel d’aujourd’hui est terminé.

Conclusion

L’installation de Kubernetes sur Ubuntu n’est pas aussi difficile qu’il n’y paraît à première vue. Le déploiement d’un cluster Kubernetes demande certes un certain effort, mais il offre en contrepartie de nombreux avantages, tels qu’une gestion centralisée plus facile, une grande évolutivité et un équilibrage de charge. Le type de déploiement Kubernetes le plus simple est un déploiement à un seul maître : vous devez installer Kubernetes sur les nœuds Ubuntu, y compris les nœuds maîtres et les nœuds de travail.Si vous avez besoin d’une infrastructure plus fiable pour exécuter des applications conteneurisées, envisagez de déployer un Kubernetes multi-maîtres, connu sous le nom de cluster Kubernetes haute disponibilité. Ce type de déploiement Kubernetes exclut tout point de défaillance unique, et votre cluster peut survivre si certains nœuds maîtres tombent en panne.Pour les deux types de déploiement, vous devez configurer l’accès SSH, définir des adresses IP et des noms d’hôte statiques, installer Docker, désactiver l’utilisation de la partition d’échange et, enfin, installer les composants Kubernetes tels que kubeadm, kubectl, kubelet et configurer Flannel pour la mise en réseau par superposition. Dans le cas du déploiement du cluster Kubernetes HA, vous devez également configurer le proxy HA sur une machine autonome, générer des certificats et configurer le cluster etcd. La plupart des étapes de configuration de Kubernetes, de création de déploiements et d’exécution de pods peuvent être effectuées de deux manières : en exécutant manuellement les commandes fournies par l’interface de ligne de commande et en utilisant des fichiers de configuration yaml. L’utilisation de fichiers yaml vous permet de créer une structure plus complexe et rend le processus d’Administration plus pratique.Vous pouvez installer Kubernetes sur Ubuntu, sur des machines physiques et virtuelles. Si votre Kubernetes est installé sur des machines virtuelles fonctionnant sous vSphere, vous pouvez bénéficier d’une protection supplémentaire en utilisant Cluster VMware haute disponibilité avec la fonctionnalité Fault Tolerance. Les logiques de déploiement Kubernetes explorées dans cet article peuvent également être utilisées pour installer Kubernetes sur d’autres distributions Linux.

Try NAKIVO Backup & Replication

Get a free trial to explore all the solution’s data protection capabilities. 15 days for free. Zero feature or capacity limitations. No credit card required.

Try for Free