Guide complet du débutant sur le déploiement du cluster Kubernetes sur CentOS (et autres Linux)

J'espère que vous connaissez les termes de base de Kubernetes tels que nœud, service, cluster, car je ne vais pas expliquer ces choses ici.

Il s'agit d'un tutoriel étape par étape pour vous montrer comment déployer un cluster Kubernetes prêt pour la production.

Prêt pour la fabrication ? Oui, les exemples utilisent un exemple de domaine. Par conséquent, si vous possédez un domaine, vous pouvez le configurer sur une infrastructure publique. Vous pouvez également l'utiliser pour des tests locaux. C'est vraiment à vous de décider.

J'ai utilisé CentOS Linux dans les exemples, mais vous devriez pouvoir utiliser n'importe quelle autre distribution Linux. À l'exception des commandes d'installation, le reste des étapes devrait être applicable à tous.

Je vais utiliser ce cluster simple d'un nœud maître/contrôle et de deux nœuds de travail :

Le didacticiel est divisé en deux parties principales.

La première partie est essentiellement un prérequis et traite de la préparation de vos machines en procédant comme suit :

• Configurez correctement les noms d'hôte sur tous les hôtes
• Désactiver le swap sur tous les nœuds
• Ajouter des règles de pare-feu
• Configurer les tables IP
• Désactiver SELinux

La deuxième partie est le déploiement réel du cluster Kubernetes et se compose des étapes suivantes :

• Configurer le référentiel Kubernetes
• Installer kubelet, kubeadm, kubectl et docker
• Activer et démarrer le service kubelet et docker
• Activer les complétions bash
• Créer un cluster avec kubeadm
• Configurer le réseau du pod
• Rejoindre des nœuds de travail
• Tester le cluster en créant un pod de test

Partie 1 :Préparer vos systèmes pour le déploiement du cluster Kubernetes

Vous avez besoin de 3 serveurs fonctionnant sur des machines virtuelles ou bare metal ou une plateforme cloud comme Linode, DigitalOcean ou Azure.

J'ai 3 machines virtuelles CentOS en cours d'exécution avec les détails suivants :

• Nœud maître Kubernetes - 172.42.42.230 kmaster-centos7.example.com/kmaster-centos7
• Nœud de travail Kubernetes 1 - 172.42.42.231 kworker-centos71.example.com/kworker-centos71
• Nœud de travail Kubernetes 2 :172.42.42.232 kworker-centos72.example.com/kworker-centos72

Veuillez vérifier les adresses IP de vos machines et modifiez-les en conséquence.

Étape 1. Configurez correctement les noms d'hôte sur tous les systèmes

Vous pouvez ajouter l'adresse IP et les informations de sous-domaine correspondantes en modifiant les enregistrements DNS de votre domaine.

Si vous n'avez pas accès au DNS, mettez à jour le fichier /etc/hosts sur les nœuds maître et travailleur avec les informations suivantes :

[[email protected] ~]# cat /etc/hosts
127.0.0.1       kmaster-centos7.example.com     kmaster-centos7
127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4
::1         localhost localhost.localdomain localhost6 localhost6.localdomain6
172.42.42.230 kmaster-centos7.example.com   kmaster-centos7
172.42.42.231 kworker-centos71.example.com  kworker-centos71
172.42.42.232 kworker-centos72.example.com  kworker-centos72
[[email protected] ~]#

Envoyez un ping aux nœuds de travail pour vérifier que les modifications du fichier hôte fonctionnent correctement.

Étape 2. Désactivez l'échange (pour des raisons de performances)

Le planificateur Kubernetes détermine le meilleur nœud disponible sur lequel déployer les pods nouvellement créés. Si l'échange de mémoire est autorisé sur un système hôte, cela peut entraîner des problèmes de performances et de stabilité au sein de Kubernetes.

Pour cette raison, Kubernetes exige que vous désactiviez le swap sur tous les nœuds :

swapoff -a

Étape 3. Ajouter des règles de pare-feu

Les nœuds, les conteneurs et les pods doivent pouvoir communiquer à travers le cluster pour exécuter leurs fonctions. Firewalld est activé par défaut dans CentOS, il serait donc sage d'ouvrir les ports requis.

Sur le nœud maître, vous avez besoin de ces ports :

• 6443 :Serveur d'API Kubernetes :utilisé par tous
• 2379–2380 :API client du serveur etcd :utilisée par kube-apiserver, etcd
• 10250 :API Kubelet :utilisée par Self, Control plane
• 10251 :kube-scheduler :utilisé par lui-même
• 10252 :kube-controller-manager :utilisé par lui-même

Sur les noeuds worker, ces ports sont requis :

• 10250 :API Kubelet :utilisée par Self, Control plane
• 30000–32767 : services NodePort :utilisés par tous

La commande firewall-cmd ouvre le port 6443 de cette manière :

firewall-cmd --permanent --add-port=6443/tcp

Sur les nœuds maître et travailleur, utilisez la commande ci-dessus pour ouvrir les ports requis qui ont été mentionnés dans cette section.

Pour la plage de ports, vous pouvez remplacer le numéro de port par la plage comme firewall-cmd --permanent --add-port=2379-2380/tcp .

Une fois que vous avez ajouté les nouvelles règles de pare-feu sur chaque machine, rechargez le pare-feu :

firewall-cmd --reload

Étape 4. Configurer iptables

Sur les nœuds maître et travailleur, assurez-vous que le br_netfilter module noyau est chargé. Cela peut être fait en exécutant lsmod | grep br_netfilter . Pour le charger explicitement, appelez sudo modprobe br_netfilter .

Définissez les net.bridge.bridge-nf-call-iptables à '1' dans votre fichier de configuration sysctl. Cela garantit que les paquets sont correctement traités par les tables IP lors du filtrage et du transfert de port.

[[email protected] ~]# cat <<EOF > /etc/sysctl.d/k8s.conf
> net.bridge.bridge-nf-call-ip6tables = 1
> net.bridge.bridge-nf-call-iptables = 1
> EOF

Exécutez cette commande pour que les modifications prennent effet :

sysctl --system

Étape 5. Désactiver SELinux (pour Red Hat et CentOS)

Les conteneurs sous-jacents seraient nécessaires pour accéder au système de fichiers hôte. CentOS est livré avec SELinux (Linux à sécurité améliorée) activé en mode d'application. Cela pourrait bloquer l'accès au système de fichiers hôte.

Vous pouvez soit désactiver SELinux, soit le configurer en mode permissif, ce qui désactive effectivement ses fonctions de sécurité.

[[email protected] ~]# setenforce 0
[[email protected] ~]# sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config
[[email protected] ~]#

Partie 2 :Déployer le cluster Kubernetes

Maintenant que vous avez configuré les paramètres corrects sur vos nœuds maître et travailleur, il est temps de démarrer le déploiement du cluster.

Étape 1. Configurer le référentiel Kubernetes

Les packages Kubernetes ne sont pas disponibles dans les référentiels CentOS 7 officiels. Cette étape doit être effectuée sur le nœud maître et sur chaque nœud de travail.

Entrez ce qui suit et vérifiez-le une fois le contenu ajouté.

[[email protected] ~]# cat <<EOF > /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://packages.cloud.google.com/yum/repos/kubernetes-el7-x86_64
enabled=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

Mettez à jour et vérifiez que le référentiel Kubernetes est ajouté à la liste des référentiels :

[[email protected] ~]# yum update -y
[[email protected] ~]# yum repolist | grep -i kubernetes
!kubernetes                         Kubernetes                               570

Étape 2. Installez kubelet, kubeadm, kubectl et Docker

kubelet, kubeadm, kubectl trois packages de base ainsi que l'exécution du conteneur (qui est docker ici) sont nécessaires pour utiliser Kubernetes.

Installez ces packages sur chaque nœud :

yum install -y kubelet kubeadm kubectl docker

Étape 3. Activer et démarrer les services kubelet et docker

Maintenant que vous avez installé les packages requis, activez (pour qu'il démarre automatiquement à chaque démarrage) kubelet et docker sur chaque nœud.

Activer kubelet sur chaque nœud :

[[email protected] ~]# systemctl enable kubelet
Created symlink from /etc/systemd/system/multi-user.target.wants/kubelet.service to /usr/lib/systemd/system/kubelet.service.

Activer Docker sur chaque nœud :

[[email protected] ~]# systemctl enable docker.service
Created symlink from /etc/systemd/system/multi-user.target.wants/docker.service to /usr/lib/systemd/system/docker.service.

Vous devez également démarrer ces services afin qu'ils puissent être utilisés immédiatement :

[[email protected] ~]# systemctl start kubelet
[[email protected] ~]# systemctl start docker.service

Étape 4. Activer l'achèvement bash (pour une vie plus facile avec Kubernetes)

Activez les complétions bash sur tous les nœuds afin de ne pas avoir à taper manuellement toutes les commandes entièrement. L'onglet le ferait pour vous.

[[email protected] ~]# echo "source <(kubectl completion bash)" >> ~/.bashrc
[[email protected] ~]# echo "source <(kubeadm completion bash)" >> ~/.bashrc
[[email protected] ~]# echo "source <(docker completion bash)" >> ~/.bashrc

Étape 5. Créer un cluster avec kubeadm

Initialisez un cluster en exécutant la commande suivante :

kubeadm init --apiserver-advertise-address=172.42.42.230 --pod-network-cidr=10.244.0.0/16

Remarque : Il est toujours bon de définir --apiserver-advertise-address spécifiquement lors du démarrage du cluster Kubernetes à l'aide de kubeadm. L'adresse IP sur laquelle le serveur API annoncera qu'il écoute. Si elle n'est pas définie, l'interface réseau par défaut sera utilisée.

Idem avec --pod-network-cidr. Spécifiez la plage d'adresses IP pour le réseau de pods. S'il est défini, le plan de contrôle allouera automatiquement des CIDR pour chaque nœud.

Pour plus d'options, veuillez consulter ce lien.

À la fin de la sortie de la commande kube-init, vous pouvez voir les étapes pour exécuter le cluster :

...
You should now deploy a pod network to the cluster.
Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:
  https://kubernetes.io/docs/concepts/cluster-administration/addons/
  
Then you can join any number of worker nodes by running the following on each as root:
kubeadm join 172.42.42.230:6443 --token 22m8k4.kajx812tg74199x3 \
    --discovery-token-ca-cert-hash sha256:03baa45e2b2bb74afddc5241da8e84d16856f57b151e450bc9d52e6b35ad8d22
```

**Manage cluster as regular user:
**In the above kube-init command output you can clearly see that to start using your cluster, you need to run the following commands as a regular user:

```bash
[[email protected] ~]# mkdir -p $HOME/.kube
[[email protected] ~]# cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
[[email protected] ~]# chown $(id -u):$(id -g) $HOME/.kube/config
[[email protected] ~]#

Vous devez exécuter ces commandes une par une pour démarrer le cluster Kubernetes :

[[email protected] ~]# mkdir -p $HOME/.kube
[[email protected] ~]# cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
[[email protected] ~]# chown $(id -u):$(id -g) $HOME/.kube/config

Étape 6. Configurer le réseau de pods

Le réseau de pod est le réseau de superposition entre les nœuds de travail. Avec le réseau de pods, les conteneurs sur différents nœuds communiquent entre eux.

Il existe plusieurs options de mise en réseau Kubernetes disponibles. Utilisez la commande suivante pour installer le module complémentaire réseau Flannel Pod :

[[email protected] ~]# kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml
podsecuritypolicy.policy/psp.flannel.unprivileged created
Warning: rbac.authorization.k8s.io/v1beta1 ClusterRole is deprecated in v1.17+, unavailable in v1.22+; use rbac.authorization.k8s.io/v1 ClusterRole
clusterrole.rbac.authorization.k8s.io/flannel created
Warning: rbac.authorization.k8s.io/v1beta1 ClusterRoleBinding is deprecated in v1.17+, unavailable in v1.22+; use rbac.authorization.k8s.io/v1 ClusterRoleBinding
clusterrolebinding.rbac.authorization.k8s.io/flannel created
serviceaccount/flannel created
configmap/kube-flannel-cfg created
daemonset.apps/kube-flannel-ds created
[[email protected] ~]#

Vérifiez l'état du cluster et vérifiez que le nœud maître (plan de contrôle) est à l'état prêt.

[[email protected] ~]# kubectl get nodes
NAME                          STATUS   ROLES    AGE   VERSION
kmaster-centos7.example.com   Ready    master   2m    v1.19.2

Vérifiez également tous les pods exécutés dans tous les espaces de noms.

kubectl get pods --all-namespaces

Étape 7. Joindre les nœuds de travail au cluster

Reportez-vous à la sortie que vous avez obtenue à l'étape 5 et copiez les commandes recommandées. Exécutez-le sur chaque noeud worker pour le connecter au cluster :

kubeadm join 172.42.42.230:6443 --token 22m8k4.kajx812tg74199x3 \
>     --discovery-token-ca-cert-hash sha256:03baa45e2b2bb74afddc5241da8e84d16856f57b151e450bc9d52e6b35ad8d22

Vérifiez à nouveau l'état du cluster pour voir que tous les nœuds de travail ont rejoint le cluster avec succès et sont prêts à servir les charges de travail.

[[email protected] ~]# kubectl get nodes -o wide
NAME                           STATUS   ROLES    AGE     VERSION   INTERNAL-IP     EXTERNAL-IP   OS-IMAGE                KERNEL-VERSION                CONTAINER-RUNTIME
kmaster-centos7.example.com    Ready    master   9m17s   v1.19.2   172.42.42.230   <none>        CentOS Linux 7 (Core)   3.10.0-1127.19.1.el7.x86_64   docker://1.13.1
kworker-centos71.example.com   Ready    <none>   7m10s   v1.19.2   172.42.42.231   <none>        CentOS Linux 7 (Core)   3.10.0-1127.19.1.el7.x86_64   docker://1.13.1
kworker-centos72.example.com   Ready    <none>   7m8s    v1.19.2   172.42.42.232   <none>        CentOS Linux 7 (Core)   3.10.0-1127.19.1.el7.x86_64   docker://1.13.1

Vérifiez tous les pods exécutés dans tous les espaces de noms :

kubectl get pods -o wide --all-namespaces

Étape 8. Testez le cluster en créant un pod de test

Maintenant que tout est en place, il est temps de tester le cluster. Créer un module :

[[email protected] ~]# kubectl run mypod1 --image=httpd --namespace=default --port=80 --labels app=fronend
pod/mypod1 created

Maintenant, vérifiez l'état du pod :

[[email protected] ~]# kubectl get pods  -o wide
NAME     READY   STATUS    RESTARTS   AGE   IP           NODE                           NOMINATED NODE   READINESS GATES
mypod1   1/1     Running   0          29s   10.244.1.2   kworker-centos71.example.com   <none>           <none>
[[email protected] ~]#

Vous disposez maintenant d'un cluster Kubernetes entièrement fonctionnel et opérationnel sur CentOS !

J'espère que vous aimez le tutoriel. Si vous avez des questions ou des suggestions, veuillez laisser un commentaire et je serai heureux de vous aider.

Et devenez membre du Linux Handbook pour profiter d'un contenu exclusif réservé aux membres.