Également connu sous le nom de k8s, Kubernetes est une plate-forme d'orchestration de conteneurs open source et portable permettant d'automatiser le déploiement et la gestion d'applications conteneurisées. Kubernetes a été initialement créé par Google dans le langage de programmation Go. Actuellement, il est maintenu par la Cloud Native Computing Foundation.
Dans ce guide, nous vous expliquerons étape par étape comment installer un cluster Kubernetes sur RHEL 8. Nous le démontrerons en utilisant un nœud principal et un nœud de travail que nous ajouterons à notre cluster.
Configuration du laboratoire
- Nœud maître : master-node-k8 10.128.15.228
- Nœud de travail : worker-node-1-k8 10.128.15.230
REMARQUE :les étapes 1 à 6 doivent être appliquées à la fois au nœud maître et au nœud de travail.
Étape 1) Désactiver l'espace d'échange
Pour de meilleures performances, Kubernetes nécessite que l'échange soit désactivé sur le système hôte. En effet, l'échange de mémoire peut entraîner de manière significative une instabilité et une dégradation des performances.
Pour désactiver l'espace d'échange, exécutez la commande :
$ sudo swapoff -a
Pour rendre les modifications persistantes, modifiez le fichier /etc/fstab et supprimez ou commentez la ligne avec l'entrée d'échange et enregistrez les modifications.
Étape 2) Désactiver SELinux
De plus, nous devons désactiver SELinux et le définir sur "permissif" afin de permettre une communication fluide entre les nœuds et les pods.
Pour ce faire, ouvrez le fichier de configuration SELinux.
$ sudo vi /etc/selinux/config
Modifiez la valeur SELINUX de l'application à la permission.
SELINUX=permissif
Vous pouvez également utiliser la commande sed comme suit.
$ sudo sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config
Étape 3) Configurer la mise en réseau dans le nœud maître et le nœud de travail
Une configuration réseau supplémentaire est requise pour que vos nœuds maître et travailleur communiquent efficacement. Sur chaque nœud, modifiez le fichier /etc/hosts.
$ sudo vi /etc/hosts
Ensuite, mettez à jour les entrées comme indiqué
10.128.15.228 master-node-k8 // Pour le nœud Master10.128.15.230 worker-node-1-k8 // Pour le nœud Worker
Enregistrez et quittez le fichier de configuration. Ensuite, installez le package de l'utilitaire de contrôle du trafic :
$ sudo dnf install -y iproute-tc
Étape 4) Autoriser les règles de pare-feu pour les k8
Pour une communication transparente entre le nœud maître et le nœud travailleur, vous devez configurer le pare-feu et autoriser certains ports et services pertinents, comme indiqué ci-dessous.
Sur le nœud maître, autorisez les ports suivants,
$ sudo firewall-cmd --permanent --add-port=6443/tcp$ sudo firewall-cmd --permanent --add-port=2379-2380/tcp$ sudo firewall-cmd --permanent --add -port=10250/tcp$ sudo firewall-cmd --permanent --add-port=10251/tcp$ sudo firewall-cmd --permanent --add-port=10252/tcp$ sudo firewall-cmd --reloadSur le nœud Worker, autorisez les ports suivants,
$ sudo firewall-cmd --permanent --add-port=10250/tcp$ sudo firewall-cmd --permanent --add-port=30000-32767/tcp $ sudo firewall-cmd --reloadÉtape 5) Installer l'environnement d'exécution du conteneur CRI-O
Kubernetes nécessite un environnement d'exécution de conteneur pour que les pods s'exécutent. Kubernetes 1.23 et les versions ultérieures nécessitent que vous installiez un environnement d'exécution de conteneur qui confirme avec l'interface d'exécution du conteneur.
Un Container Runtime est une application qui prend en charge l'exécution de conteneurs. Kubernetes prend en charge l'environnement d'exécution de conteneur suivant :
- Conteneur
- CRI-O
- Moteur Docker
- Exécution du conteneur Mirantis
Dans ce guide, nous allons installer CRI-O qui est un environnement d'exécution de conteneur de haut niveau. Pour ce faire, nous devons activer deux modules cruciaux du noyau :les modules overlay et br_netfilter.
Pour ce faire, nous devons configurer les prérequis comme suit :
Commencez par créer un fichier de configuration de modules pour Kubernetes.
$ sudo vi /etc/modules-load.d/k8s.conf
Ajoutez ces lignes et enregistrez les modifications
overlaybr_netfilter
Chargez ensuite les deux modules à l'aide de la commande modprobe.
$ sudo modprobe overlay$ sudo modprobe br_netfilter
Ensuite, configurez les paramètres sysctl requis comme suit
$ sudo vi /etc/sysctl.d/k8s.conf
Ajoutez les lignes suivantes :
net.bridge.bridge-nf-call-iptables =1net.ipv4.ip_forward =1net.bridge.bridge-nf-call-ip6tables =1
Enregistrez les modifications et quittez. Pour confirmer que les modifications ont été appliquées, exécutez la commande :
$ sudo sysctl --system
Pour installer CRI-O, définissez la variable d'environnement $VERSION pour qu'elle corresponde à votre version de CRI-O. Par exemple, pour installer CRI-O version 1.21, définissez la $VERSION comme indiqué :
$ export VERSION=1.21
Ensuite, exécutez les commandes suivantes :
$ sudo curl -L -o /etc/yum.repos.d/devel:kubic:libcontainers:stable.repo https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable /CentOS_8/devel:kubic:libcontainers:stable.repo
$ sudo curl -L -o /etc/yum.repos.d/devel:kubic:libcontainers:stable:cri-o:$VERSION.repo https://download.opensuse.org/repositories/devel:kubic :libcontainers:stable:cri-o:$VERSION/CentOS_8/devel:kubic:libcontainers:stable:cri-o:$VERSION.repo
Utilisez ensuite le gestionnaire de packages DNF pour installer CRI-O :
$ sudo dnf install cri-o
Ensuite, activez CRI-O au démarrage et démarrez-le :
$ sudo systemctl enable cri-o$ sudo systemctl start cri-o
Étape 6) Installer les packages Kubernetes
Avec tout ce qui est nécessaire pour que Kubernetes fonctionne, installons les packages Kubernetes tels que kubelet, kubeadm et kubectl. Créez un fichier de référentiel Kubernetes.
$ sudo vi /etc/yum.repos.d/kubernetes.repo
Et ajoutez les lignes suivantes.
[kubernetes]name=Kubernetesbaseurl=https://packages.cloud.google.com/yum/repos/kubernetes-el7-x86_64enabled=1gpgcheck=1repo_gpgcheck=1gpgkey=https://packages.cloud.google.com/ yum/doc/yum-key.gpg https://packages.cloud.google.com/yum/doc/rpm-package-key.gpgexclude=kubelet kubeadm kubectl
Enregistrez les modifications et quittez. Enfin, installez le package k8s comme suit.
$ sudo dnf install -y kubelet kubeadm kubectl --disableexcludes=kubernetes
Une fois installé, assurez-vous d'activer et de démarrer le service Kubelet.
$ sudo systemctl enable kubelet$ sudo systemctl start kubelet
À ce stade, nous sommes tous prêts à installer le cluster Kubernetes.
Étape 7) Créer un cluster Kubernetes
Nous allons initialiser un cluster Kubernetes à l'aide de la commande kubeadm comme suit. Cela initialise un plan de contrôle dans le nœud maître.
$ sudo kubeadm init --pod-network-cidr=192.168.10.0/16
Une fois le plan de contrôle créé, vous devrez exécuter quelques commandes supplémentaires pour commencer à utiliser le cluster.
Par conséquent, exécutez les commandes, de manière séquentielle.
$ mkdir -p $HOME/.kube$ sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config$ sudo chown $(id -u):$(id -g) $HOME /.kube/config
À la toute fin de la sortie, vous recevrez la commande à exécuter sur les nœuds de travail pour rejoindre le cluster. Nous y reviendrons plus tard à l'étape suivante.
Assurez-vous également de supprimer les rejets du nœud maître :
$ kubectl taint nodes –all node-role.kubernetes.io/master-
Étape 8) Installer le module complémentaire Calico Pod Network
L'étape suivante consiste à installer Calico CNI (Container Network Interface). Il s'agit d'un projet open source utilisé pour fournir la mise en réseau et la sécurité des conteneurs. Après l'installation de Calico CNI, l'état des nœuds passera à l'état Prêt, le service DNS à l'intérieur du cluster sera fonctionnel et les conteneurs pourront commencer à communiquer entre eux.
Calico offre évolutivité, hautes performances et interopérabilité avec les charges de travail Kubernetes existantes. Il peut être déployé sur site et sur des technologies cloud populaires telles que Google Cloud, AWS et Azure.
Pour installer Calico CNI, exécutez la commande suivante à partir du nœud maître
$ kubectl create -f https://docs.projectcalico.org/manifests/tigera-operator.yaml
Une fois terminé, exécutez celui-ci.
$ kubectl create -f https://docs.projectcalico.org/manifests/custom-resources.yaml
Pour vérifier si les pods ont démarré, exécutez la commande :
$ watch kubectl get pods -n calico-system
Vous devriez voir que chaque pod est "PRÊT" et a le statut "RUNNING" comme indiqué dans la troisième colonne.
Pour vérifier la disponibilité du nœud maître dans le cluster, exécutez la commande :
$ kubectl get nodes
De plus, vous pouvez récupérer plus d'informations en utilisant les options -o large.
$ kubectl get nodes -o wide
La sortie ci-dessus confirme que le nœud maître est prêt. De plus, vous pouvez vérifier les espaces de noms des pods :
$ kubectl get pods --all-namespaces
Étape 9) Ajouter un nœud de travail au cluster
Pour ajouter le nœud de travail au cluster Kubernetes, suivez l'étape 1 jusqu'à l'étape 6. Une fois que vous avez terminé, exécutez la commande générée par le nœud maître pour joindre un nœud de travail au cluster. Dans notre cas, ce sera :
$ sudo kubeadm join 10.128.15.228:6443 --token cqb8vy.iicmmqrb1m8u9cob --discovery-token-ca-cert-hash sha256:79748a56f603e6cc57f67bf90b7db5aebe090107d540d6cc8a8f675b785depre>Si tout se passe bien, vous devriez recevoir la notification indiquant que le nœud a rejoint le cluster. Répétez la même procédure pour les autres nœuds au cas où vous auriez plusieurs nœuds de travail
Maintenant, revenez au nœud maître et, encore une fois, vérifiez les nœuds de votre cluster. Cette fois-ci, le nœud de travail apparaîtra dans la liste sur les nœuds du cluster,
$ kubectl get nodes
Conclusion
C'était un aperçu de la façon dont vous pouvez installer un cluster Kubernetes sur RHEL 8. Vos commentaires sur ce guide sont les bienvenus.
