Comment installer Kubernetes sur Ubuntu
Le déploiement manuel de conteneurs Docker sur plusieurs serveurs peut s’avérer très chronophage, accaparant ainsi l’emploi du temps de tout administrateur système chargé de cette tâche. Dans le secteur informatique moderne, la popularité du cloud, des microservices et des conteneurs ne cesse de croître, ce qui a conduit au développement de solutions telles que Kubernetes.
Kubernetes est une solution open source de gestion et d’orchestration de conteneurs qui 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é aux applications conteneurisées. L’objectif de cet article est d’expliquer comment installer Kubernetes sur Ubuntu pour exécuter des applications dans des conteneurs Docker.
Configuration matérielle et système requise pour l’installation de 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 à remplir 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 à ouvrir pour installer Kubernetes sur Ubuntu :
| Protocole et plage de ports | Source | Objectif | Direction |
| TCP 443 | Nœuds de travail, utilisateurs finaux, requêtes API | Serveur API Kubernetes | Entrant vers le nœud maître |
| TCP 10250 | Nœuds maîtres | Port de vérification de l’état du Kubelet sur les nœuds de travail | Entrant vers les nœuds de travail |
| TCP 30000-32767 | Clients d’applications externes | Plage de ports par défaut pour la fourniture de services externes | |
| UDP 8285 | Nœuds de travail | Backend UDP du réseau superposé Flannel | |
| UDP 8472 | Nœuds de travail | Backend VXLAN du réseau superposé Flannel | |
| TCP 179 | Nœuds de travail | Requis uniquement si le réseau Calico BGP est utilisé | |
| TCP 2379-2380 | Nœuds maîtres | API client du serveur etcd | Trafic entrant vers le nœud etcd |
| TCP 2379-2380 | Nœuds de travail | API client du serveur etcd requise si Flannel ou Calico est utilisé |
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 tester 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. Il s’agit des règles 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 s’effectuer aussi bien sur des machines physiques que virtuelles. Il est généralement recommandé d’utiliser la dernière version d’Ubuntu Linux 64 bits. L’article de blog d’aujourd’hui explique comment installer Kubernetes sur Ubuntu 18.04 LTS fonctionnant sur des VMs VMware. Le premier type de déploiement Kubernetes présenté prévoit un nœud maître et deux nœuds de travail pour le cluster Kubernetes. Affichez le tableau ci-dessous pour connaître le nombre de nœuds (selon les cas de figure), les rôles des nœuds, les noms d’hôte et les adresses IP des machines utilisées dans l’exemple considéré.
| N° | Rôle du nœud | Adresse IP | Nom d’hôte |
| 1 | Maître | 192.168.101.21 | docker-nakivo21 |
| 2 | Ouvrier | 192.168.101.31 | docker-nakivo31 |
| 3 | Ouvrier | 192.168.101.32 | docker-nakivo32 |
Vous pouvez utiliser des VMs s’exécutant sur des hôtes VMware ESXi si vous utilisez VMware vSphere, ou bien 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 réseau NAT Réseaux 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.53
L’adresse IP de la passerelle virtuelle pour le réseau NAT (VMNet8) : 192.168.101.2
Le même utilisateur Linux existe sur toutes les machines Ubuntu : kubernetes-user
Configuration de la machine virtuelle : 2 cœurs, 4 Go de RAM, disque virtuel de 20 Go
Vous pouvez modifier les adresses IP du réseau VMNet8 en vous rendant à l’adresse Edit > Virtual Network Editor dans VMware Workstation.
Pour plus de clarté, 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éez une nouvelle machine virtuelle nommée docker-nakivo21 .
Installez Ubuntu 64 bits sur la première machine, puis définissez le nom d’hôte et le nom d’utilisateur.
VM-Name : docker-nakivo21
Nom d’utilisateur : kubernetes-user
Installez 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 caractère $ au début signifie qu’une commande est exécutée en tant qu’utilisateur standard ( kubernetes-user dans ce cas). Si la chaîne commence par le caractère # , la commande doit être exécutée en tant que root . La commande sudo (à remplacer par le nom de l’utilisateur ou du super utilisateur) vous permet d’exécuter des commandes en tant qu’un 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 (voir explications ci-dessous).
$ sudo apt-get install open-vm-tools
Si vous avez besoin de fonctionnalités avancées du bureau telles que le presse-papiers partagé, le glisser-déposer de fichiers, etc., exécutez :
$ sudo apt-get install open-vm-tools-desktop
Redémarrez la machine virtuelle.
$ init 6
Configurer votre machine Ubuntu avant d’installer Kubernetes
Certaines préparations sont nécessaires avant d’installer Kubernetes sur des machines Ubuntu. Tout d’abord, vous devez configurer l’adresse IP statique et le nom d’hôte, comme pour tout serveur classique.
Définissez l’adresse IP statique
Comme pour tout autre type de cluster, l’utilisation d’adresses IP statiques sur les nœuds est fortement recommandée.
Installez les outils réseau Linux avant de définir l’adresse IP.
$ sudo apt-get install net-tools
Tapez ifconfig pour vérifier l’adresse IP actuelle de votre machine virtuelle Ubuntu.
Vous pouvez constater 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 vim
Dans les dernières versions d’Ubuntu, la configuration réseau est définie dans un fichier YAML. Ouvrez le fichier YAML de configuration réseau dans vim.
$ sudo vim /etc/netplan/01-network-manager-all.yaml
L’affichage par défaut du fichier de configuration est le suivant :
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]
Enregistrez les modifications et quittez.
:wq
$ sudo netplan try
Appuyez sur ENTRÉE pour accepter la nouvelle configuration.
Vérifiez si votre configuration de mise en 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.
$ hostnamectl
Comme vous vous en souvenez, le nom d’hôte de la première machine virtuelle, à savoir docker-nakivo21 , a déjà été configuré lors de l’installation. Pour modifier le nom d’hôte, procédez comme suit (cette opération sera nécessaire pour configurer les deuxième et troisième VMs après leur clonage. Ces deux VMs sont destinées à être configurées en tant que nœuds de travail) :
Par exemple, si vous devez modifier le nom d’hôte en docker-nakivo21 sur la première VMs, exécutez : $ sudo hostnamectl set-hostname docker-nakivo21
Vérifiez que le nouveau nom d’hôte est bien pris en compte.
$ less /etc/hostname
Modifiez le fichier hosts .
$ sudo vim /etc/hosts
Le contenu du fichier hosts doit ressembler à ceci :
127.0.0.1 localhost
127.0.1.1 docker-nakivo21
Redémarrez la machine.
$ init 6
Désactiver un fichier swap
L’utilisation de fichiers swap (partition swap) n’est pas prise en charge par Kubernetes et il est nécessaire de désactiver le paramètre « swappiness » pour réussir l’installation de Kubernetes sur Ubuntu.
Désactivez le fichier swap pour éviter une utilisation élevée du processeur par kubelet.
$ sudo swapoff -a
Modifiez /etc/fstab et mettez la ligne en commentaire à l’aide du caractère # .
$ sudo vim /etc/fstab
#/swapfile Aucune swap sw 0 0
Vous pouvez faire la même chose avec sed en une seule commande :
$ sudo sed -i '/ swap / s/^(.*)$/#1/g' /etc/fstab
Désactivez l’espace d’échange dans sysctl.conf
$ sudo echo "vm.swappiness=0" | sudo tee --append /etc/sysctl.conf
Où 0 correspond au pourcentage de swapiness. Dans ce cas, l’espace d’échange ne peut être utilisé que si vous êtes à court de RAM (par défaut, l’espace d’échange est utilisé lorsque plus de 60 % de la RAM est occupée).
Appliquez les modifications de configuration sans redémarrer.
$ sudo sysctl -p
Remarque : si la partition swap n’est pas désactivée, le kswapd0 processus d’Ubuntu Linux exécutant Kubernetes peut consommer une grande quantité de ressources de processeur sur votre machine, ce qui peut entraîner une absence de réponse des applications et un blocage du système. Cela se produit lorsque le système d’exploitation est à court de mémoire et que les anciennes pages de mémoire sont déplacées vers la partition swap par un processus système du noyau Linux. Pour des raisons inconnues, il arrive parfois que cela tourne mal et qu’une boucle sans fin, consommant toutes les ressources du processeur, se produise. Sur la capture d’écran ci-dessous, vous pouvez constater une forte consommation de CPU par le processus kswapd0 lorsque Kubernetes est installé sur Ubuntu. La valeur moyenne de la charge est excessivement élevée.
Si kswapd0 continue de surcharger votre processeur, exécutez la commande suivante pour vider tous les caches mémoire et arrêter kswapd0 (à exécuter en tant que root).
# echo 1 > /proc/sys/vm/drop_caches
Arrêtez la machine virtuelle.
$ init 0
Cette machine virtuelle partiellement configurée ( docker-nakivo21 ) est sur le point d’être utilisée 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 les étapes précédentes manuellement (ou utilisez des outils d’automatisation tels qu’Ansible pour configurer simultanément plusieurs VMs via SSH). Comme cet exemple utilise des VMs, celles-ci 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 machine virtuelle
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 sur ce sujet, consultez notre article de blog à l’adresse Clonage de VMs par l’intermédiaire de modèles de VMs. Si vous utilisez VMware Workstation, vous pouvez également cloner des VMs de deux façons (par l’outil de clonage intégré ou manuellement). Vous pouvez cliquer sur VM > Manage > Clone pour créer un clone lié. Créons un clone complet de la première machine virtuelle et copions manuellement les fichiers de la machine virtuelle. Dans ce cas, les fichiers sont copiés depuis le répertoire docker-nakivo21 vers docker-nakivo31. Les répertoires doivent être créés manuellement avant de copier les fichiers de la machine virtuelle.
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:VirtualKUBERNETESdocker-nakivo31docker-nakivo31.vmdk"
nvram = "docker-nakivo31.nvram"
La machine virtuelle qui servira de premier nœud de travail est désormais créée. Clonez à nouveau la première machine virtuelle afin de préparer le deuxième nœud de travail du cluster Kubernetes.
Modifiez le fichier VMX de la troisième machine virtuelle (le deuxième nœud de travail), comme vous l’avez fait précédemment.
displayName = "docker-nakivo32"
scsi0:0.fileName = "C:VirtualKUBERNETESdocker-nakivo31docker-nakivo32.vmdk"
nvram = "docker-nakivo32.nvram"
Ouvrez les clones de la machine virtuelle dans VMware Workstation (File> Open et sélectionnez le fichier VMX de la machine virtuelle), ou double-cliquez simplement sur le fichier VMX de la machine virtuelle. Mettez sous tension les trois machines virtuelles (votre machine virtuelle source et les deux clones). Cliquez sur « I Copied It » , lorsque vous y êtes invité.
Remarque : si vous utilisez des machines virtuelles, modifiez l’adresse IP et le nom d’hôte de chaque clone de machine virtuelle une fois que les VMs ont été clonées. Si vous utilisez des machines physiques, suivez toutes les étapes précédentes en fonction de vos adresses IP et noms d’hôte pour chaque machine.
Configuration des adresses IP et des noms d’hôte sur les VMs
Modifiez l’adresse IP et le nom d’hôte sur docker-nakivo31 et docker-nakivo32 (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.
Les adresses IP doivent être : 192.168.101.31 et 192.168.101.32 ; les noms d’hôte doivent être respectivement docker-nakivo31 et docker-nakivo32 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 hosts de sur chaque machine. Modifions le fichier hosts de .
Ajoutez les chaînes suivantes au fichier hosts de sur chaque machine ( docker-nakivo21 , docker-nakivo31 , docker-nakivo32 ).
$ sudo vim /etc/hosts
Ajoutez ces lignes au fichier hosts de :
192.168.101.21 docker-nakivo21
192.168.101.31 docker-nakivo31
192.168.101.32 docker-nakivo32
Effectuez un ping vers d’autres hôtes depuis chaque hôte pour vous assurer que les noms d’hôte 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-server
Accédez au répertoire personnel de kubernetes-user 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 permettent d’accéder à la console Linux distante via SSH sans utiliser de mot 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-keygen
Il n’est pas nécessaire de saisir un mot de passe pour la génération des clés (le mot de passe est facultatif).
Copiez les clés sur d’autres machines Ubuntu :
$ ssh-copy-id kubernetes-user@192.168.101.31
$ ssh-copy-id kubernetes-user@192.168.101.32
Saisissez votre mot de passe utilisateur pour confirmer la copie des clés.
Essayez de vous connecter à la deuxième machine ( docker-nakivo31 ) en tant que kubernetes-user (il s’agit d’un utilisateur standard).
$ ssh 'kubernetes-user@192.168.101.31'
Testez ensuite la connexion à la troisième machine ( docker-nakivo32 ).
$ ssh 'kubernetes-user@192.168.101.32'
Une fois la connexion établie, le nom de la machine distante s’affichera dans l’invite de commande de votre console après la connexion.
Appuyez sur Ctrl+D pour quitter la console distante.
Comment copier la clé permettant de 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 -i
Modifiez le fichier de configuration du serveur SSH.
# vim /etc/ssh/sshd_config
Ajoutez/modifiez la chaîne suivante dans ce fichier.
PermitRootLogin yes
Redémarrez le démon du serveur SSH.
# /etc/init.d/ssh stop
# /etc/init.d/ssh start
Définissez le mot de passe root (mot de passe de l’utilisateur root).
# passwd
$ cd /home/kubernetes-user/
$ sudo ssh-keygen -t rsa
Copiez la clé publique pour pouvoir vous connecter à distance via SSH en tant que root (la clé est stockée dans le répertoire personnel de l’utilisateur standard puisque 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.1
Si votre clé est enregistrée dans le répertoire personnel de l’utilisateur root, copiez-la à l’aide de cette commande :
# ssh-copy-id -i /root/.ssh/id_rsa.pub 127.0.0.1
Confirmez cette opération et saisissez votre mot de passe.
Répétez l’opération en copiant la clé de chaque machine vers les autres machines. Par exemple, sur la machine docker-nakivo21 , exécutez :
# 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.32
Autorisez la clé publique.
# cat /root/.ssh/id_rsa.pub >> /root/.ssh/authorized_keys
Überprüfen Sie, ob Sie als utilisateur root via SSH auf der lokalen Maschine zugreifen können. $ sudo ssh root@127.0.0.1
Essayez de vous connecter depuis/vers la machine distante sans saisir de mot de passe.
$ sudo ssh root@192.168.101.21
$ sudo ssh root@192.168.101.31
$ sudo ssh root@192.168.101.32
Remarque : Se connecter en tant qu’utilisateur root peut présenter un risque de sécurité. Ne vous connectez pas en tant que root si ce n’est pas nécessaire ; il est préférable de vous connecter via SSH en tant qu’utilisateur standard et d’utiliser la commande sudo .
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-nakivo32 .
Cependant, il n’y a pas lieu de se précipiter. Pour commencer, vous pouvez simplement installer Docker par la commande habituelle :
$ sudo apt-get install -y docker.io
Toutefois, 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-common
Curl est un outil universel et compact conçu pour transférer des données depuis/vers un hôte sans intervention de l’utilisateur, par l’utilisation d’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 dépôt officiel de Docker à 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 dépôt officiel de Docker à votre gestionnaire de paquets apt :
$ sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu bionic stable"
Mettez à jour la base de données de votre gestionnaire de paquets après avoir effectué les modifications manuelles par la commande précédente.
$ sudo apt-get update
Vérifiez la version du paquet Docker disponible dans le dépôt officiel.
$ apt-cache policy docker-ce
Installez Docker.
$ sudo apt-get install docker-ce
Vous pouvez vérifier la version de Docker après l’installation.
$ docker --version
Dans ce cas, la sortie est la suivante : 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 docker
Une 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
À présent, plus rien ne vous empêche d’installer les composants principaux de Kubernetes.
Exécutez les commandes en tant qu’administrateur sur toutes les machines devant être intégrées au cluster Kubernetes.
$ sudo -i
Ajoutez la clé GPG du référentiel officiel de 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 de Kubernetes à la liste des référentiels de paquets disponibles pour votre gestionnaire de paquets apt.
# cat <<EOF >/etc/apt/sources.list.d/kubernetes.list
deb http://apt.kubernetes.io/ kubernetes-xenial main
EOF
Vous pouvez également ajouter le référentiel à l’aide de cette commande : # echo 'deb http://apt.kubernetes.io/ kubernetes-xenial main' | sudo tee /etc/apt/sources.list.d/kubernetes.list
Où tee est un outil qui lit l’entrée standard et écrit les données d’entrée vers 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 update
L’installation de kubectl , kubeadm et kubectl est indispensable pour installer Kubernetes sur Ubuntu.
# apt-get install -y kubelet kubeadm kubectl
Installez keepalived.
# apt-get install keepalived
# systemctl enable keepalived && systemctl start keepalived
Überprüfen Sie, dass die Wert zu 1 gesetzt ist, um die Funktionalität von Kubernetes auf Ubuntu zu gewährleisten.
# sysctl net.bridge.bridge-nf-call-iptables
Um diesen Wert auf 1 zu setzen, exekutieren Sie die Kommandozeilen-Anweisung:
sysctl net.bridge.bridge-nf-call-iptables=1
Modifizieren Sie den Konfigurations-Datei-Eintrag für kubeadm.
# vim /etc/systemd/system/kubelet.service.d/10-kubeadm.conf
Fügen Sie die Zeichenkette nach der Zeichenkette « Environment » hinzu:
Environment=”cgroup-driver=systemd/cgroup-driver=cgroupfs”
Die cgroups sind Gruppen des Kontrolldesigns, die die Nutzung der Ressourcen wie Prozessor, RAM, Datentransfer und Netzwerk isolieren.
Sur le nœud maître ( docker-nakivo21 ), exécutez la commande pour initialiser le cluster Kubernetes sous Ubuntu.
# kubeadm init --pod-network-cidr=10.244.0.0/16 --apiserver-advertise-address=192.168.101.21
Où
–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 de réseau définit également le nombre de pods pouvant s’exécuter 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 en tant que serveur API.
Lisez la sortie et enregistrez les commandes affichées à la fin du texte. C’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 init. Dans 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/config
Si 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 automatiquement ce fichier de configuration dans le répertoire utilisateur. Vous devez effectuer cette opération manuellement.
Vérifiez les nœuds ajoutés au cluster
# kubectl get nodes
Vous pouvez voir un nœud maître présentant le statut NotReady dans le cluster Kubernetes en cours d’installation sur Ubuntu. Cela est dû au fait que le réseau overlay n’a pas été configuré. Configurez Flannel afin de corriger le statut NotReady du nœud maître Kubernetes. Créez le répertoire destiné à stocker les fichiers YAML pour Docker et Kubernetes, par exemple : /home/kubernetes-user/kubernetes/
Le langage YAML (Yet Another Markup Language) vous offre un plus grand confort lors de la création de pods et de déploiements dans Kubernetes. Vous pouvez définir tous les paramètres des conteneurs à déployer dans le fichier de configuration YAML, au lieu d’exécuter manuellement chaque commande dans la console Linux. Les fichiers YAML sont également appelés « fichiers de manifeste » dans le contexte de Kubernetes.
Créez le fichier de configuration YAML avec le contenu suivant :
Exécutez la commande
# kubectl apply -f ./kube-flannel.yml
Vous pouvez également trouver sur GitHub des exemples gratuits de configurations de déploiement YAML pour Kubernetes.
kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/a70459be0084506e4ec919aa1c114638878db11b/Documentation/kube-flannel.yml
Vérifiez les nœuds ajoutés au cluster Kubernetes que vous déployez sur Ubuntu :
# kubectl get nodes
Le statut du nœud maître est désormais « Ready ».
Assurez-vous que Flannel a été correctement configuré :
# kubectl get pods --all-namespaces
Vous pouvez constater que le pod Flannel est en cours d’exécution. Ce pod se compose de deux conteneurs : le démon Flannel et un initContainer utilisé pour effectuer le déploiement de la configuration CNI dans un emplacement accessible à Kubernetes.
Parfois, lors de l’installation de 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 dépassé.
Comment résoudre ce problème ? Attendez quelques secondes et réessayez — cela suffit souvent.
Les espaces de noms sont des entités logiques au sein du 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 Default , Kube-public , et Kube-system . Vous pouvez obtenir la liste des espaces de noms :
# kubectl get namespaces
Comme vous vous en souvenez, l’unité de déploiement de base dans Kubernetes est un pod, qui est un ensemble de conteneurs partageant un espace de noms réseau et 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 pods
Si vous souhaitez réinitialiser/arrêter le cluster, exécutez :
# kubeadm reset
Tout fonctionne correctement sur le nœud maître. Cela signifie que vous pouvez désormais poursuivre l’installation de 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:65ace7a4ff6fff795abf086f18d5f0d97da71d4639a0d0a6b93f42bea4948a79
Le jeton et le hachage ont été notés après l’initialisation du cluster avec la commande kubeadm init , comme vous vous en souvenez peut-être.
Sur le nœud maître, vérifiez à nouveau le statut du cluster. # kubectl get nodes
Vous pouvez désormais voir un nœud maître et deux nœuds de travail 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 déployer un pod contenant des conteneurs dans votre cluster Kubernetes. Comme vous vous en souvenez, les conteneurs sont inclus dans les pods sous Kubernetes. Si vous utilisez des fichiers YAML, créez un répertoire pour stocker ces fichiers, ce qui vous facilitera la tâche. Accédez à ce répertoire et exécutez les commandes suivantes : kubectl apply -f test.yaml
Un 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éplicas. Vous pouvez créer un déploiement à l’aide d’une seule commande ou par l’utilisation 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.yaml
Affichez la pièce jointe pour voir la configuration.
# vim mysql-deployment.yaml
Il existe deux approches courantes pour la gestion des ressources avec kubectl . Quelle est la différence entre kubectl create et kubectl apply ? Lorsque vous utilisez kubectl create , vous indiquez à Kubernetes ce que vous souhaitez créer, remplacer ou supprimer ; cette commande écrase toutes les modifications. Sinon, kubectl apply effectue des modifications incrémentielles et cette commande peut être utilisée pour enregistrer les modifications appliquées à un objet en production.
Créer un déploiement :
# kubectl apply -f ./mysql-deployment.yaml
Kubernetes peut afficher des informations sur votre déploiement.
# kubectl describe deployment mysql
Vérifier les pods :
# kubectl get po
ou
# kubectl get pods
ou
# kubectl get pods -l app=mysql
Si le pod affiche le statut « pending », cela peut signifier qu’il n’y a pas suffisamment de ressources de calcul. Essayez d’ajouter de la capacité de processeur et de la mémoire pour résoudre le statut « en attente » du pod dans Kubernetes.
Vous pouvez supprimer le service si nécessaire :
# kubectl delete service <service_name>
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éez un déploiement.
# kubectl create deployment nginx --image=nginx
Vérifiez que le déploiement a bien été créé.
# kubectl get deployments
Créez un service.
# kubectl create service nodeport nginx --tcp=80:80
Un 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 entre 30000 et 32767 est attribué pour accéder aux services fournis. Le trafic acheminé vers ce port est redirigé vers le service concerné.
Vérifiez que le service a bien été créé et qu’il est à l’écoute sur le port défini.
# kubectl get svc
Notez le numéro du port (31453 dans le cas présent).
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 notés à l’étape précédente.
# curl docker-nakivo31:31453
Vous pouvez également vérifier que le service est accessible depuis le navigateur de n’importe quel nœud. Dans la barre d’adresse du navigateur Web, essayez d’accéder aux pages suivantes :
http:// 10.101.235.90
ou
http://docker-nakivo31:31453
http://docker-nakivo32:31453
Si tout se passe bien, vous verrez s’afficher la page d’accueil de nginx.
Il est également possible d’accéder à la page de test nginx depuis n’importe quelle machine ayant accès au réseau auquel les nœuds Kubernetes sont connectés — ( 192.168.101.0/24 ) dans le cas présent. Par exemple, vous pouvez consulter 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 surveiller Kubernetes. Pour installer le tableau de bord, créez le fichier kubernetes-dashboard.yaml , 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.yaml
Vérifier les pods.
# kubectl get pods -o wide --all-namespaces
Démarrez le proxy vers le serveur API Kubernetes.
# kubectl proxy
Pour saisir 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:8001
Vous pouvez voir la page de test.
Saisissez 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 –decode
Vous pouvez désormais voir le jeton généré :
Copiez le jeton généré et collez-le dans la section « token » 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 consulter 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 d’autres éléments. Créez un fichier manifeste nommé heapster.yaml .
# vim heapster.yaml
À l’étape suivante, déployez Heapster.
# kubectl create -f heapster.yaml
Modifiez le rôle RBAC (Contrôle d’accès basé sur les rôles) de Heapster et ajoutez les autorisations nécessaires pour accéder aux statistiques des nœuds.
# kubectl edit clusterrole system:heapster
Vérifiez que les métriques relatives au processeur et à la mémoire peuvent être consultées dans la console.
# kubectl top node
Vous 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 nœuds maîtres sous Ubuntu
Disposer d’un cluster Kubernetes avec un seul nœud maître et quelques nœuds de travail est une bonne option, mais il arrive parfois que le nœud maître unique 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 capable d’assurer la tolérance aux pannes est de trois. Si vous utilisez plus de trois nœuds maîtres et que leur nombre est pair, la tolérance aux pannes de l’ensemble du cluster n’augmente pas. Consultez le tableau ci-dessous pour comparer le niveau de 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 comportant 5 nœuds maîtres, celui-ci peut résister à la défaillance de 2 nœuds maîtres, car trois nœuds maîtres restent opérationnels (3 sur 5, soit plus de 50 %, ce qui constitue la majorité). La taille du cluster fait référence au nombre de nœuds maîtres dans le cluster.
| Taille du cluster | Majorité | Tolérance aux pannes |
| 1 | 1 | 0 |
| 2 | 2 | 0 |
| 3 | 2 | 1 |
| 4 | 3 | 1 |
| 5 | 3 | 2 |
| 6 | 4 | 2 |
| 7 | 4 | 3 |
| 8 | 5 | 3 |
| 9 | 5 | 4 |
Cette section de l’article 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 quelques nœuds de travail. Dans le tableau ci-dessous, vous pouvez voir les adresses IP, les noms d’hôte et les rôles des hôtes utilisés pour l’installation du cluster Kubernetes HA sur des nœuds Ubuntu dans le laboratoire de test présenté dans cet exemple.
| N° | Rôle du nœud | Adresse IP | Nom d’hôte |
| 1 | Maître | 192.168.101.21 | docker-nakivo21 |
| 2 | Maître | 192.168.101.22 | docker-nakivo22 |
| 3 | Maître | 192.168.101.23 | docker-nakivo23 |
| 4 | HA Proxy | 192.168.101.19 | ha-proxy19 |
| 5 | Worker | 192.168.101.31 | docker-nakivo31 |
| 6 | Worker | 192.168.101.32 | docker-nakivo32 |
Certaines commandes sont identiques à celles utilisées pour installer Kubernetes sur Ubuntu avec 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 consulter à nouveau 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 :
- Configurez les adresses IP statiques.
- Définissez les noms d’hôte. Les noms de tous les hôtes doivent être résolus en adresses IP.
- L’accès SSH doit être activé et configuré à l’aide de certificats.
- L’espace d’échange doit être désactivé.
Ces étapes doivent être effectuées avant de lancer l’installation de Docker sur chaque machine, tout comme ce que vous avez pu lire dans la section ci-dessus consacrée à l’installation de Kubernetes sur Ubuntu par l’intermédiaire d’un seul nœud maître. Une fois toutes les machines préparées, rendez-vous sur ( 192.168.101.19 ).
Configuration de l’équilibreur de charge HA Proxy
L’équilibreur de charge HA Proxy sert à répartir le trafic entrant entre les nœuds Kubernetes. Il est déployé en amont des nœuds maîtres. Ouvrez la console de la machine ha-proxy19 et effectuez les actions indiquées ci-dessous.
Installez cfssl
Cfssl (CloudFlare SSL) est une suite d’outils permettant de générer différents certificats, notamment des chaînes de certificats TLS/SSL.
Téléchargez les binaires depuis le dépôt officiel.
# wget https://pkg.cfssl.org/R1.2/cfssl_linux-amd64
# wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64
Rendez 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 von cfssl überprüfen.
# cfssl version
Mettez à jour le référentiel.
# apt-get update
Installez HA Proxy.
# apt-get install haproxy
Créez et modifiez le fichier haproxy.cfg .
# vim /etc/haproxy/haproxy.cfg
Ajoutez ces lignes à la fin de ce fichier de configuration.
frontend kubernetes
bind 192.168.101.19:6443
option tcplog
mode tcp
default_backend kubernetes-master-nodes
backend kubernetes-master-nodes
mode tcp
balance roundrobin
option tcp-check
server docker-nakivo21 192.168.101.21:6443 check fall 3 rise 2
server docker-nakivo22 192.168.101.22:6443 check fall 3 rise 2
server docker-nakivo23 192.168.101.23:6443 check fall 3 rise 2
Redémarrez le service.
# systemctl restart haproxy
Générez des certificats TLS
Vous pouvez continuer à utiliser la console de la machine HAProxy. Créez le fichier de configuration de l’autorité de certification, nommé ca-config.json .
# vim ca-config.json
Ajoutez le contenu suivant à ce fichier de configuration :
{
"signing": {
"default": {
"expiry": "8760h"
},
"profiles": {
"kubernetes": {
"usages": ["signing", "key encipherment", "server auth", "client auth"],
"expiry": "8760h"
}
}
}
}
Créez le fichier de configuration de la demande de signature de l’autorité de certification.
# vim ca-csr.json
Ajoutez le contenu suivant à ce fichier :
{
« CN »: « Kubernetes »,
« key »: {
« algo »: « rsa »,
« size »: 2048
},
« names »: [
{
« C »: « GB »,
« L »: « London »,
« O »: « Kubernetes »,
« OU »: « CA »,
« ST »: « Nakivo »
}
]
}
Où :
C – pays, par exemple GB (Grande-Bretagne).
L – emplacement, tel qu’une ville ou une localité.
O – organisation.
OU – unité organisationnelle (par exemple, un service défini comme propriétaire de la clé).
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 die Schlüssel ca-key.pem und ca.pem gerechtfertigt sind.
# ls -al
Création du certificat für den Etcd-Cluster
Etcd unterstützt die Kommunikation zwischen Servern/Clustern über eine Authentifizierung mit Client-Certificaten. Vous devez disposer d’un certificat d’autorité de certification (CA) et d’une paire de clés signée 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 kubernetes
Affichez la liste des fichiers de votre répertoire pour vérifier que les fichiers kubernetes-key.pem et kubernetes.pem ont bien été générés.
# ls -al
Copiez 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 le répertoire personnel de kubernetes-user sur les hôtes Ubuntu.
Préparation des nœuds Ubuntu en vue de l’installation de Kubernetes
Exécutez les commandes indiquées dans cette section sur tous les nœuds maîtres et tous les nœuds de travail. Installez Docker, puis installez Kubernetes sur les machines Ubuntu qui feront partie du 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-ce
Docker est désormais installé. kubeadm, kublet et kubectl sont les composants Kubernetes nécessaires à l’installation de Kubernetes sur Ubuntu.
Installez les composants Kubernetes : kubeadm, kubelet 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 kubectl
Une 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 système de stockage cohérent et hautement disponible, destiné à stocker des clés ainsi que pour sauvergarder toutes les données du cluster. Le cluster etcd doit être configuré avant de configurer le cluster Kubernetes haute disponibilité (HA) comportant 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 machine.
Créez un répertoire de configuration pour etcd.
# mkdir /etc/etcd /var/lib/etcd
Accédez au répertoire dans lequel les certificats ont été copiés. Il s’agit du répertoire personnel de l’utilisateur kubernetes, dans ce cas : /home/kubernetes-user/
Copiez les certificats dans le répertoire de configuration d’etcd.
# cp ca.pem kubernetes.pem kubernetes-key.pem /etc/etcd
Überprüfen Sie, dass die Dateien kopiert wurden.
# ls -al /etc/etcd
Revenez zum vorherigen Repertoire
# cd -
Téléchargez die Binarys von etcd aus dem Referentiel.
# wget https://github.com/coreos/etcd/releases/download/v3.3.9/etcd-v3.3.9-linux-amd64.tar.gz
Décompressez l’archive etcd.
# tar xvzf etcd-v3.3.9-linux-amd64.tar.gz
Déplacez ensuite les fichiers binaires etcd vers /usr/local/bin/
# mv etcd-v3.3.9-linux-amd64/etcd* /usr/local/bin/
Créez un fichier d’unité systemd pour etcd.
# vim /etc/systemd/system/etcd.service
Ajoutez les chaînes de caractères indiquées ci-dessous à ce fichier.
[Unit]
Description=etcd
Documentation=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/etcd
Restart=on-failure
RestartSec=5
[Install]
WantedBy=multi-user.target
Rechargez la configuration du gestionnaire systemd afin de prendre en compte les modifications apportées au système de fichiers et de régénérer les arborescences de dépendances.
# systemctl daemon-reload
Configurez etcd pour qu’il démarre au démarrage du système.
# systemctl enable etcd
Démarrez etcd. # systemctl start etcd
Répétez ces 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 de configuration etcd.service . Définissez les adresses IP correctes pour chaque autre nœud maître. Par exemple, le fichier de configuration etcd.service doit se présenter comme suit pour le deuxième nœud maître ( 192.168.101.22 ) du laboratoire de test Kubernetes actuel.
[Unit]
Description=etcd
Documentation=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/etcd
Restart=on-failure
RestartSec=5
[Install]
WantedBy=multi-user.target
Initialisation des nœuds maîtres dans le cluster Kubernetes HA
Vous pouvez désormais initialiser les nœuds maîtres de 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.yaml
Ajoutez les paramètres de configuration à ce fichier :
apiVersion: kubeadm.k8s.io/v1alpha3
kind: ClusterConfiguration
kubernetesVersion: stable
apiServerCertSANs:
- 192.168.101.19
controlPlaneEndpoint: "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.pem
networking:
podSubnet: 10.244.0.0/16
apiServerExtraArgs:
apiserver-count: "3"
Le réseau défini comme podSubnet (10.244.0.0/16) doit être identique à celui du fichier kube-flannel.yml .
Initialisez la machine Ubuntu en tant que nœud maître.
# kubeadm init --config=config.yaml
Il arrive parfois qu’un avertissement s’affiche 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 », ce qui écrira la nouvelle spécification, similaire, en utilisant une version plus récente de l’API.
Mettez à jour la version du fichier de configuration à l’aide de la commande :
# kubeadm config migrate --old-config config.yaml --new-config config1.yaml
Une 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]: Get https://192.168.101.21:2379/version: dial tcp 192.168.101.21:2379: connect: connection refused
Vérifiez si votre etcd est en cours d’exécution. Vous pouvez lancer manuellement etcd :
# systemctl start etcd
Aprè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 ajouter des nœuds au cluster. Enregistrez ces chaînes de caractères importantes, car vous en aurez besoin prochainement. Elles sont surlignées en jaune sur la capture d’écran et sont reproduites ci-dessous.
Vous pouvez désormais intégrer autant de nœuds de plan de contrôle que vous le souhaitez en copiant les autorités de certification
et les clés de compte de service sur chaque nœud, puis en exécutant la commande suivante en tant qu’utilisateur root :
kubeadm join 192.168.101.19:6443 --token sxm34y.p4rn4328vne0iihf
--discovery-token-ca-cert-hash sha256:bf3887f1565fcd48ff696da98a761ac1b70c6d38ba0ba3e4b1bf573000a302ca
--experimental-control-plane
Vous pouvez ensuite intégrer autant de nœuds de travail que vous le souhaitez en exécutant la commande suivante sur chacun d’entre eux en tant qu’utilisateur root :
kubeadm join 192.168.101.19:6443 --token sxm34y.p4rn4328vne0iihf
--discovery-token-ca-cert-hash sha256:bf3887f1565fcd48ff696da98a761ac1b70c6d38ba0ba3e4b1bf573000a302ca
Exécutez les commandes suivantes pour commencer à utiliser le nœud initialisé au sein du cluster.
# mkdir -p $HOME/.kube
# sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
# sudo chown $(id -u):$(id -g) $HOME/.kube/config
Vérifiez les nœuds ajoutés au cluster.
# kubectl get nodes
Copiez les certificats sur 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 les fichiers apiserver.crt et apiserver.key qui se trouvent dans le répertoire personnel (~) de l’utilisateur kubernetes-user .
$ rm ~/pki/apiserver.*
Déplacez les certificats stockés dans le répertoire personnel vers le répertoire /etc/kubernetes/ .
$ sudo mv ~/pki /etc/kubernetes/
Créez le fichier de configuration YAML pour kubeadm.
# vim config.yaml
Le contenu de ce fichier YAML est identique à celui du premier nœud maître ( 192.168.101.21 ). Reportez-vous à la configuration d’initialisation du premier nœud maître ci-dessus. Vous pouvez copier le fichier déjà créé et 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.yaml
La sortie est identique à celle affichée après l’initialisation du premier nœud maître dans le cluster Kubernetes HA :
De la même manière, 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/config
Vérifiez les nœuds ajoutés au cluster.
# kubectl get nodes
Deux 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 l’initialisation du deuxième nœud (192.168.101.22) du cluster. N’oubliez pas de noter les commandes accompagnées du jeton et des hachages permettant d’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 statut « NotReady » des nœuds qui s’affiche, car aucun réseau superposé n’est encore configuré. Créez le kube-flannel.yaml fichier à l’aide de l’éditeur de texte vim, par exemple, sur le premier nœud maître.
# kubectl apply -f kube-flannel.yml
Notez l’adresse du podSubnet définie dans le fichier config.yaml . L’adresse réseau doit être la même dans le fichier kube-flannel.yaml .
Vérifiez vos nœuds et leur statut.
# kubectl get nodes
Tous les nœuds maîtres fonctionnent désormais 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 Kubernetes HA déployé sur des machines Ubuntu. Utilisez la commande affichée après l’initialisation des nœuds maîtres (celle qui contient le jeton et le hachage) pour faire rejoindre le cluster au nœud de travail. Exécutez la commande sur la machine 192.168.101.31 .
# kubeadm join 192.168.101.19:6443 --token kxl1gf.6ddalutd60n0ez45
--discovery-token-ca-cert-hash sha256:bf3887f1565fcd48ff696da98a761ac1b70c6d38ba0ba3e4b1bf573000a302ca
Vérifiez les nœuds du cluster Kubernetes à haute disponibilité pour vous assurer que le nœud de travail a bien été ajouté. Vous pouvez également voir désormais la machine proxy HA dans la liste des nœuds.
# kubectl get nodes
De la même manière, ajoutez d’autres nœuds de travail au cluster Kubernetes à haute disponibilité installé sur des 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’elle peut le paraître à 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 simplifiée, une grande évolutivité et l’équilibrage de charge. Le type de déploiement Kubernetes le plus simple est le déploiement à un seul maître : vous devez installer Kubernetes sur des nœuds Ubuntu, comprenant à la fois des nœuds maîtres et des 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ître, également appelé « cluster Kubernetes à haute disponibilité ». Ce type de déploiement Kubernetes élimine tout point de défaillance unique, et votre cluster peut continuer à fonctionner même 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 swap, puis installer les composants Kubernetes tels que kubeadm, kubectl et kubelet, et enfin 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 ainsi que d’exécution de pods peuvent être réalisées de deux manières : en exécutant manuellement les commandes fournies par l’interface en ligne de commande, ou en utilisant des fichiers de configuration YAML. L’utilisation de fichiers YAML vous permet de créer des structures plus complexes et facilite le processus d’Administration.
Vous pouvez installer Kubernetes sur Ubuntu, aussi bien sur des machines physiques que 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 principes de déploiement de Kubernetes abordés dans cet article de blog peuvent également être utilisés pour installer Kubernetes sur d’autres distributions Linux.
