Le processus d'installation d'un Cluster Kubernetes sur CentOS 8 est presque semblable à celui de CentOS 7 (que vous pouvez parcourir ici), mais le processus ici a quelques changements. Ces changements tournent principalement autour de l'installation de Docker.
Commençant par CentOS 8 (et par extension RHEL 8), docker a maintenant été remplacé nativement par podman et buildah qui sont des outils de Chapeau rouge. En fait, le package docker a maintenant été supprimé du référentiel de packages par défaut.
Avec ce mouvement, le Chapeau rouge team vise à simplifier le processus de création et d'utilisation des conteneurs, sans avoir besoin d'autorisations spéciales, tout en maintenant la compatibilité avec les images Docker et en les utilisant sans avoir besoin d'un démon. Podman promet d'offrir plus de flexibilité lors de l'exécution sur Kubernetes environnements, mais le jury reste là-bas.
Pour cet article, nous allons parcourir le processus d'installation Kubernetes sur un CentOS 8 plate-forme, fonctionnant sur
Docker-CE (Edition communautaire). Dans un article ultérieur, nous passerons également en revue une installation similaire, en utilisant podman pour nos conteneurs.La plupart des nœuds sont généralement livrés avec des MAC adresses, cependant, dans certains cas uniques, certains Machines virtuelles peuvent avoir des adresses MAC identiques. Il est donc recommandé de confirmer que le Produit_UUID et le MAC les adresses ne sont identiques dans aucun des nœuds.
Kubernetes utilise ces valeurs pour identifier de manière unique les nœuds du cluster. Si ces valeurs ne sont pas uniques à chaque nœud, le processus d'installation peut échouer.
Pour vérifier l'adresse MAC de l'interface réseau et la comparer.
# lien IP.
Pour vérifier le product_uuid et comparez, exécutez la commande suivante.
# cat /sys/class/dmi/id/product_uuid
Notre installation est conçue pour avoir le Nœud maître contrôler le Nœuds de travail. À la fin de cette installation, notre architecture logique ressemblera à ceci.
Nœud maître – Cette machine agit généralement comme le plan de contrôle et exécute la base de données du cluster et le serveur API (avec lequel la CLI kubectl communique).
Notre 3-nœud Cluster Kubernetes ressemblera à quelque chose comme ceci :
Pour Kubernetes pour fonctionner, vous aurez besoin d'un moteur de conteneurisation. Comme mentionné, nous utiliserons Docker-CE.
Les institutions suivantes seront exécutées le Nœud maître CentOS 8.
Sur votre Nœud maître CentOS 8, définissez le nom d'hôte du système et mettez à jour le DNS dans votre /etc/hosts fichier.
# hostnamectl set-hostname master-node. # chat <> /etc/hosts. 192.168.0.47 nœud maître. 192.168.0.48 nœud-1 nœud de travail-1. 192.168.0.49 nœud-2 nœud de travail-2. EOF.
Ensuite, envoyez un ping à votre nœud-travailleur-1 et nœud-travailleur-2 pour vérifier si votre fichier hôte mis à jour fonctionne correctement en utilisant le commande ping.
# ping 192.168.0.48. # ping 192.168.0.49.
Ensuite, désactivez Selinux, car cela est nécessaire pour permettre aux conteneurs d'accéder au système de fichiers hôte, ce qui est nécessaire aux réseaux de pods et à d'autres services.
# définir force 0.
Réglage imposer à 0
définit effectivement SELinux sur permissif, ce qui désactive effectivement SELinux jusqu'au prochain redémarrage. Pour le désactiver complètement, utilisez la commande ci-dessous et redémarrez.
# sed -i --follow-symlinks 's/SELINUX=enforcing/SELINUX=disabled/g' /etc/sysconfig/selinux. # redémarrer.
Kubernetes utilise divers ports pour la communication et l'accès et ces ports doivent être accessibles à Kubernetes et non limités par le pare-feu.
Configurez les règles de pare-feu sur les ports.
# firewall-cmd --permanent --add-port=6443/tcp. # firewall-cmd --permanent --add-port=2379-2380/tcp. # firewall-cmd --permanent --add-port=10250/tcp. # firewall-cmd --permanent --add-port=10251/tcp. # firewall-cmd --permanent --add-port=10252/tcp. # firewall-cmd --permanent --add-port=10255/tcp. # firewall-cmd --reload. # modprobe br_netfilter. # echo '1' > /proc/sys/net/bridge/bridge-nf-call-iptables.
Vous devrez ajouter le Docker référentiel d'abord car il n'est plus dans la liste des packages par défaut en utilisant ce qui suit dnf config-manager commander.
# dnf config-manager --add-repo= https://download.docker.com/linux/centos/docker-ce.repo.
Installer aussi containerd.io package disponible en tant que démon qui gère le cycle de vie complet du conteneur de son système hôte, de transfert et stockage d'images vers l'exécution et la supervision du conteneur vers le stockage de bas niveau vers les pièces jointes au réseau et au-delà.
# dnf installer https://download.docker.com/linux/centos/7/x86_64/stable/Packages/containerd.io-1.2.6-3.3.el7.x86_64.rpm.
Installez maintenant la dernière version d'un docker-ce paquet.
# dnf installe docker-ce.
Vous pouvez maintenant activer et démarrer le service Docker.
# systemctl active le docker. # systemctl démarre le docker.
Ensuite, vous devrez ajouter Kubernetes référentiels manuellement car ils ne sont pas installés par défaut sur CentOS 8.
# chat </etc/yum.repos.d/kubernetes.repo. [kubernetes] nom=Kubernetes. baseurl= https://packages.cloud.google.com/yum/repos/kubernetes-el7-x86_64. activé=1. gpgcheck=1. repo_gpgcheck=1. gpgkey= https://packages.cloud.google.com/yum/doc/yum-key.gpg https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg. EOF.
Kubeadm vous aide à amorcer un cluster Kubernetes minimum viable et conforme aux meilleures pratiques. Avec kubeadm, votre cluster doit réussir les tests de conformité Kubernetes.
Kubeadm prend également en charge d'autres fonctions de cycle de vie du cluster, telles que les mises à niveau, la rétrogradation et la gestion des jetons d'amorçage. Kubeadm est également compatible avec d'autres outils d'orchestration tels que Ansible et Terraforme.
Avec le dépôt de packages maintenant prêt, vous pouvez aller de l'avant et installer kubeadm paquet.
# dnf install kubeadm -y
Une fois l'installation terminée, activez et démarrez le service.
# systemctl active kubelet. # systemctl démarrer kubelet.
Le maître Kubernetes qui agit comme le avion de contrôle pour le cluster exécute quelques services critiques nécessaires au cluster. En tant que tel, le processus d'initialisation effectuera une série de précontrôles pour s'assurer que la machine est prête à exécuter Kubernetes. Ces précontrôles exposent des avertissements et se terminent en cas d'erreur. kubeadm init puis télécharge et installe les composants du plan de contrôle du cluster.
Il est maintenant temps d'initialiser le maître Kubernetes, mais avant cela, vous devez désactiver le swap pour exécuter "kubeadm init" commande.
# échange -a.
Initialisation Kubernetes master est un processus entièrement automatisé qui est contrôlé par le "kubeadm init" commande comme indiqué.
# kubeadm init.
Ensuite, copiez la commande suivante et stockez-la quelque part, car nous devions exécuter cette commande sur les nœuds de travail ultérieurement.
kubeadm join 192.168.0.47:6443 --token nu06lu.xrsux0ss0ixtnms5 \ --discovery-token-ca-cert-hash ha256:f996ea35r4353d342fdea2997a1cf8caeddafd6d4360d606dbc82314783478hjmf
Pointe: Parfois, la commande ci-dessus peut générer des erreurs sur les arguments passés, donc pour éviter les erreurs, vous devez supprimer le ‘\’
caractère et votre commande finale ressemblera à ceci.
# kubeadm join 192.168.0.47:6443 --token nu06lu.xrsux0ss0ixtnms5 –discovery token-ca-cert-hash sha256:f996ea35r4353d342fdea2997a1cf8caeddafd6d4360d606dbc82314783478hjmf
Une fois Kubernetes initialisé avec succès, vous devez permettre à votre utilisateur de commencer à utiliser le cluster. Dans notre scénario, nous utiliserons l'utilisateur root. Vous pouvez également démarrer le cluster à l'aide de l'utilisateur sudo, comme indiqué.
Utiliser racine, Cours:
# mkdir -p $HOME/.kube. # cp -i /etc/kubernetes/admin.conf $HOME/.kube/config. # chown $(id -u):$(id -g) $HOME/.kube/config.
Pour utiliser un utilisateur activé sudo, Cours:
$ mkdir -p $HOME/.kube. $ sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config. $ sudo chown $(id -u):$(id -g) $HOME/.kube/config.
Confirmez maintenant que le commande kubectl est activé.
# kubectl obtient des nœuds.
A ce moment, vous verrez que le statut du master-node est ‘Pas prêt’. En effet, nous n'avons pas encore déployé le réseau de pods sur le cluster.
Le réseau de pods est le réseau superposé du cluster, qui est déployé au-dessus du réseau de nœuds actuel. Il est conçu pour permettre la connectivité à travers le pod.
Le déploiement du cluster réseau est un processus très flexible en fonction de vos besoins et de nombreuses options sont disponibles. Puisque nous voulons garder notre installation aussi simple que possible, nous utiliserons tissage plugin qui ne nécessite aucune configuration ou code supplémentaire et il fournit une adresse IP par pod, ce qui est excellent pour nous. Si vous voulez voir plus d'options, veuillez vérifier ici.
Ces commandes seront importantes pour obtenir la configuration du réseau du pod.
# export kubever=$(kubectl version | base64 | tr -d '\n') # kubectl applique -f " https://cloud.weave.works/k8s/net? k8s-version=$kubever"
Maintenant, si vous vérifiez l'état de votre nœud maître, il devrait être 'Prêt’.
# kubectl obtient des nœuds.
Ensuite, nous ajoutons le nœuds de travail au cluster.
Les instructions suivantes seront exécutées sur chaque nœud de travail en rejoignant le cluster Kubernetes.
Définissez d'abord le nom d'hôte sur votre nœud-travailleur-1 et nœud-travailleur-2, puis ajoutez les entrées d'hôte au /etc/hosts fichier.
# hostnamectl set-hostname 'node-1' # chat <> /etc/hosts. 192.168.0.47 nœud maître. 192.168.0.48 nœud-1 nœud de travail-1. 192.168.0.49 nœud-2 nœud de travail-2. EOF.
Ensuite, envoyez un ping à votre nœud maître de ton nœuds de travail pour confirmer que votre fichier hôte mis à jour fonctionne correctement en utilisant le commande ping.
# 192.168.0.47.
Ensuite, désactivez SElinux et mettez à jour vos règles de pare-feu.
# définir force 0. # sed -i --follow-symlinks 's/SELINUX=enforcing/SELINUX=disabled/g' /etc/sysconfig/selinux. # firewall-cmd --permanent --add-port=6783/tcp. # firewall-cmd --permanent --add-port=10250/tcp. # firewall-cmd --permanent --add-port=10255/tcp. # firewall-cmd --permanent --add-port=30000-32767/tcp. # firewall-cmd --reload. # echo '1' > /proc/sys/net/bridge/bridge-nf-call-iptables.
Ajoutez d'abord le référentiel Docker à l'aide de DNF config-manager.
# dnf config-manager --add-repo= https://download.docker.com/linux/centos/docker-ce.repo.
Ensuite, ajoutez le containerd.io paquet.
# dnf installer https://download.docker.com/linux/centos/7/x86_64/stable/Packages/containerd.io-1.2.6-3.3.el7.x86_64.rpm.
Une fois ces deux packages installés, installez la dernière version de docker-ce.
# dnf installe docker-ce.
Activez et démarrez le service Docker.
# systemctl active le docker. # systemctl démarre le docker.
Vous devrez ajouter Kubernetes référentiels manuellement car ils ne sont pas préinstallés sur CentOS 8.
# chat </etc/yum.repos.d/kubernetes.repo. [kubernetes] nom=Kubernetes. baseurl= https://packages.cloud.google.com/yum/repos/kubernetes-el7-x86_64. activé=1. gpgcheck=1. repo_gpgcheck=1. gpgkey= https://packages.cloud.google.com/yum/doc/yum-key.gpg https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg. EOF.
Avec le dépôt de packages maintenant prêt, vous pouvez aller de l'avant et installer kubeadm.
# dnf install kubeadm -y
Démarrez et activez le service.
# systemctl active kubelet. # systemctl démarrer kubelet.
Nous avons maintenant besoin du jeton qui kubeadm init généré, pour rejoindre le cluster. Vous pouvez le copier et le coller dans votre nœud-1 et nœud-2 si vous l'aviez copié quelque part.
# kubeadm join 192.168.0.47:6443 --token nu06lu.xrsux0ss0ixtnms5 --discovery-token-ca-cert-hash sha256:f996ea35r4353d342fdea2997a1cf8caeddafd6d4360d606dbc82314683478hjmmm
Comme suggéré sur la dernière ligne, retournez à votre nœud-maître et vérifier si le travailleur nœud-1 et nœud de travail-2 ont rejoint le cluster à l'aide de la commande suivante.
# kubectl obtient des nœuds.
Si toutes les étapes s'exécutent avec succès, vous devriez voir nœud-1 et nœud-2 en état prêt sur le nœud-maître. À ce stade, vous avez maintenant déployé avec succès un cluster Kubernetes sur CentOS 8.
Lecture recommandée: Comment déployer Nginx sur un cluster Kubernetes
Le cluster que nous avons créé ici a un seul Nœud maître, et à ce titre, si le Nœud maître échoue, votre cluster peut perdre des données et peut devoir être recréé à partir de zéro.
Pour cette raison, je recommande une configuration hautement disponible.