Comment utiliser Kubeadm pour configurer un cluster Kubernetes hautement disponible

Enterprise 2020-11-04 23:25:23 views: null

Lorsque nous configurons un cluster Kubernetes (k8s) localement pour l'environnement de production, il est recommandé de le déployer avec une haute disponibilité. La haute disponibilité signifie l'installation d'un nœud maître ou nœud de travail Kubernetes dans HA. Dans cet article, je vais vous montrer comment configurer un cluster Kubernetes hautement disponible à l'aide de l'utilitaire kubeadm.

Pour démontrer, j'ai utilisé cinq systèmes CentOS 7 avec les détails suivants:

  • k8s-master-1 - CentOS 7 minimum - 192.168.1.40 - 2 Go de RAM, 2vCPU, disque de 40 Go
  • k8s-master-2 - CentOS 7 minimum - 192.168.1.41 - 2 Go de RAM, 2vCPU, disque de 40 Go
  • k8s-master-3 - CentOS 7 minimum - 192.168.1.42 - 2 Go de RAM, 2vCPU, disque de 40 Go
  • k8s-worker-1 - CentOS 7 minimum - 192.168.1.43 - 2 Go de RAM, 2vCPU, disque de 40 Go
  • k8s-worker-2 - CentOS 7 minimum - 192.168.1.44 - 2 Go de RAM, 2vCPU, disque de 40 Go

Comment utiliser Kubeadm pour configurer un cluster Kubernetes hautement disponible

Remarque: le cluster etcd peut également être formé en dehors du nœud maître, mais pour cela, nous avons besoin de matériel supplémentaire, j'ai donc installé etcd dans le nœud maître.

Définissez la configuration minimale requise pour la haute disponibilité du cluster K8:

  • Installez Kubeadm, kubelet et kubectl sur tous les nœuds maître et worker
  • Connexion réseau entre le nœud maître et le nœud worker
  • Connexion Internet sur tous les nœuds
  • Informations d'identification racine ou utilisateur privilégié sudo sur tous les nœuds

Passons les étapes d'installation et de configuration.

Étape 1. Définissez le nom d'hôte et ajoutez des entrées dans le fichier / etc / hosts

Exécutez la hostnamectlcommande pour définir le nom d'hôte sur chaque nœud. Par exemple, l'exemple montre le nœud maître K8:

$ hostnamectl set-hostname "k8s-master-1"
$ exec bash

De même, exécutez les commandes ci-dessus sur les nœuds restants et définissez leurs noms d'hôte respectifs. Après avoir défini les noms d'hôte sur tous les nœuds maîtres et nœuds de travail /etc/hosts, ajoutez les entrées suivantes dans les fichiers sur tous les nœuds .

192.168.1.40   k8s-master-1
192.168.1.41   k8s-master-2
192.168.1.42   k8s-master-3
192.168.1.43   k8s-worker-1
192.168.1.44   k8s-worker-2
192.168.1.45   vip-k8s-master

J'ai utilisé une autre entrée "192.168.1.45 vip-k8s-master" dans le fichier hosts car j'utiliserai cette adresse IP et ce nom d'hôte lors de la configuration de haproxy et de rester connecté sur tous les nœuds maîtres. Cette adresse IP sera utilisée comme adresse IP de l'équilibreur de charge kube-apiserver. Toutes les requêtes kube-apiserver atteindront cette adresse IP, puis les requêtes seront distribuées aux nœuds kube-apiserver réels sur le backend.

Étape 2. Installez et configurez Keepalive et HAProxy sur tous les nœuds maître / travailleur

Utilisez les yumcommandes suivantes pour installer keepalived et haproxy sur chaque nœud maître:

$ sudo yum install haproxy keepalived -y

Tout d'abord, configurez Keepalived sur k8s-master-1, le check_apiserver.shscript de création obtiendra le contenu suivant:

[kadmin@k8s-master-1 ~]$ sudo vi /etc/keepalived/check_apiserver.sh
#!/bin/sh
APISERVER_VIP=192.168.1.45
APISERVER_DEST_PORT=6443

errorExit() {
    echo "*** $*" 1>&2
    exit 1
}

curl --silent --max-time 2 --insecure https://localhost:${APISERVER_DEST_PORT}/ -o /dev/null || errorExit "Error GET https://localhost:${APISERVER_DEST_PORT}/"
if ip addr | grep -q ${APISERVER_VIP}; then
    curl --silent --max-time 2 --insecure https://${APISERVER_VIP}:${APISERVER_DEST_PORT}/ -o /dev/null || errorExit "Error GET https://${APISERVER_VIP}:${APISERVER_DEST_PORT}/"
fi

Enregistrez et quittez le fichier, définissez les autorisations exécutables:

$ sudo chmod + x /etc/keepalived/check_apiserver.sh

Sauvegardez le keepalived.conffichier, puis videz le fichier.

[kadmin@k8s-master-1 ~]$ sudo cp /etc/keepalived/keepalived.conf /etc/keepalived/keepalived.conf-org
[kadmin@k8s-master-1 ~]$ sudo sh -c '> /etc/keepalived/keepalived.conf'

Maintenant, collez ce qui suit dans le /etc/keepalived/keepalived.conffichier

[kadmin@k8s-master-1 ~]$ sudo vi /etc/keepalived/keepalived.conf
! /etc/keepalived/keepalived.conf
! Configuration File for keepalived
global_defs {
    router_id LVS_DEVEL
}
vrrp_script check_apiserver {
  script "/etc/keepalived/check_apiserver.sh"
  interval 3
  weight -2
  fall 10
  rise 2
}

vrrp_instance VI_1 {
    state MASTER
    interface enp0s3
    virtual_router_id 151
    priority 255
    authentication {
        auth_type PASS
        auth_pass P@##D321!
    }
    virtual_ipaddress {
        192.168.1.45/24
    }
    track_script {
        check_apiserver
    }
}

Enregistrez et fermez le fichier.

Remarque: pour les nœuds master-2 et 3, seuls deux paramètres de ce fichier doivent être modifiés. L'état des nœuds maîtres 2 et 3 passera à la SLAVEpriorité 254 et 253 respectivement.

Configurez HAProxy sur le nœud k8s-master-1, modifiez son fichier de configuration et ajoutez le contenu suivant:

[kadmin@k8s-master-1 ~]$ sudo cp /etc/haproxy/haproxy.cfg /etc/haproxy/haproxy.cfg-org

Supprimez toutes les lignes après la section par défaut et ajoutez les lignes suivantes

[kadmin@k8s-master-1 ~]$ sudo vi /etc/haproxy/haproxy.cfg
#---------------------------------------------------------------------
# apiserver frontend which proxys to the masters
#---------------------------------------------------------------------
frontend apiserver
    bind *:8443
    mode tcp
    option tcplog
    default_backend apiserver
#---------------------------------------------------------------------
# round robin balancing for apiserver
#---------------------------------------------------------------------
backend apiserver
    option httpchk GET /healthz
    http-check expect status 200
    mode tcp
    option ssl-hello-chk
    balance     roundrobin
        server k8s-master-1 192.168.1.40:6443 check
        server k8s-master-2 192.168.1.41:6443 check
        server k8s-master-3 192.168.1.42:6443 check

Enregistrez et quittez le fichier.

Comment utiliser Kubeadm pour configurer un cluster Kubernetes hautement disponible

Copiez maintenant ces trois fichiers (check_apiserver.sh, keepalived.conf et haproxy.cfg) de k8s-master-1 vers k8s-master-2 et 3

Exécutez la boucle for suivante pour copier ces fichiers scp dans les master 2 et 3;

[kadmin@k8s-master-1 ~]$ for f in k8s-master-2 k8s-master-3; do scp /etc/keepalived/check_apiserver.sh /etc/keepalived/keepalived.conf root@$f:/etc/keepalived; scp /etc/haproxy/haproxy.cfg root@$f:/etc/haproxy; done

Remarque: n'oubliez pas de modifier keepalived.confles deux paramètres du fichier dont nous avons discuté ci-dessus pour k8s-master-2 et 3 .

Si le pare-feu est exécuté sur le nœud maître, ajoutez les règles de pare-feu suivantes sur les trois nœuds maîtres

$ sudo firewall-cmd --add-rich-rule='rule protocol value="vrrp" accept' --permanent
$ sudo firewall-cmd --permanent --add-port=8443/tcp
$ sudo firewall-cmd --reload

Maintenant, démarrez et activez les services keepalived et haproxy sur les trois nœuds maîtres à l'aide des commandes suivantes:

$ sudo systemctl enable keepalived --now
$ sudo systemctl enable haproxy --now

Une fois ces services démarrés avec succès, veuillez vérifier si VIP (IP virtuelle) a été activée sur le nœud k8s-master-1, car nous avons marqué k8s-master-1 comme nœud MASTER dans le fichier de configuration keepalived.

Comment utiliser Kubeadm pour configurer un cluster Kubernetes hautement disponible

Parfait, la sortie ci-dessus confirme que VIP a été activé sur k8s-master-1.

Étape 3. Désactivez la partition d'échange et définissez SELinux comme règles d'autorisation et règles de pare-feu pour les nœuds principaux et secondaires

Pour désactiver l'espace d'échange sur tous les nœuds (y compris les nœuds de travail), exécutez la commande suivante:

$ sudo swapoff -a 
$ sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab

Définissez SELinux sur Permissive sur tous les nœuds maîtres et nœuds de travail, et exécutez la commande suivante,

$ sudo setenforce 0
$ sudo sed -i's / ^ SELINUX = enforcing $ / SELINUX = permissive /'/ etc / selinux / config

Règles de pare-feu du nœud maître:

Si le pare-feu est exécuté sur le nœud maître, les ports suivants sont autorisés dans le pare-feu

Comment utiliser Kubeadm pour configurer un cluster Kubernetes hautement disponible

Exécutez la commande firewall-cmd suivante sur tous les nœuds maîtres:

$ 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 --permanent --add-port=179/tcp
$ sudo firewall-cmd --permanent --add-port=4789/udp
$ sudo firewall-cmd --reload
$ sudo modprobe br_netfilter
$ sudo sh -c "echo '1' > /proc/sys/net/bridge/bridge-nf-call-iptables"
$ sudo sh -c "echo '1' > /proc/sys/net/ipv4/ip_forward"

Règles de pare-feu pour les nœuds de travail:

Si le pare-feu est en cours d'exécution sur les nœuds worker, autorisez les ports suivants dans le pare-feu sur tous les nœuds worker

Comment utiliser Kubeadm pour configurer un cluster Kubernetes hautement disponible

Exécutez la commande suivante sur tous les nœuds de calcul:

$ sudo firewall-cmd --permanent --add-port=10250/tcp
$ sudo firewall-cmd --permanent --add-port=30000-32767/tcp                                                   
$ sudo firewall-cmd --permanent --add-port=179/tcp
$ sudo firewall-cmd --permanent --add-port=4789/udp
$ sudo firewall-cmd --reload
$ sudo modprobe br_netfilter
$ sudo sh -c "echo '1' > /proc/sys/net/bridge/bridge-nf-call-iptables"
$ sudo sh -c "echo '1' > /proc/sys/net/ipv4/ip_forward"

Étape 4. Installez Docker Container Operation (CRI) sur les nœuds maître et worker

Installez Docker sur tous les nœuds maîtres et de travail, exécutez la commande suivante

$ sudo yum install -y yum-utils
$ sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
$ sudo yum install docker-ce -y

Exécutez la commande systemctl suivante pour démarrer et activer le service docker (exécutez également cette commande sur tous les nœuds maîtres et de travail)

$ sudo systemctl enable docker --now

Maintenant, installons kubeadm, kubelet et kubectl à l'étape suivante

Étape 5. Installez Kubeadm, kubelet et kubectl

Installez kubeadm, kubelet et kubectl sur tous les nœuds principaux et secondaires. Avant d'installer ces packages, nous devons configurer le référentiel de référentiel Kubernetes et exécuter les commandes suivantes sur chaque nœud maître et nœud de travail

cat <<EOF | sudo tee /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://packages.cloud.google.com/yum/repos/kubernetes-el7-\$basearch
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
exclude=kubelet kubeadm kubectl
EOF

Maintenant, exécutez sous la commande yum pour installer ces packages

$ sudo yum install -y kubelet kubeadm kubectl --disableexcludes=kubernetes

Exécutez la commande systemctl suivante pour activer le service kubelet sur tous les nœuds (nœuds maître et nœuds de calcul)

$ sudo systemctl enable kubelet --now

Étape 6. Initialisez le cluster Kubernetes à partir du premier nœud maître

Accédez maintenant au premier terminal de nœud maître et exécutez la commande suivante

[kadmin@k8s-master-1 ~]$ sudo kubeadm init --control-plane-endpoint "vip-k8s-master:8443" --upload-certs

Dans la commande ci-dessus, --control-plane-endpointle nom DNS et le port de l'équilibreur de charge (kube-apiserver) sont définis. Dans mon cas, le nom DNS est "vip-k8s-master" et le port est "8443", sauf que cette --upload-certsoption sera automatiquement Partagez des certificats entre les nœuds maîtres.

Le résultat de la commande kubeadm est le suivant:

Comment utiliser Kubeadm pour configurer un cluster Kubernetes hautement disponible

Excellent, la sortie ci-dessus confirme que le cluster Kubernetes a été initialisé avec succès. Dans la sortie, nous avons également obtenu des commandes pour que d'autres nœuds maîtres et nœuds de travail rejoignent le cluster.

Remarque: il est recommandé de copier cette sortie dans un fichier texte pour référence future.

Exécutez la commande suivante pour permettre aux utilisateurs locaux d'interagir avec le cluster à l'aide des commandes kubectl

[kadmin@k8s-master-1 ~]$ mkdir -p $HOME/.kube
[kadmin@k8s-master-1 ~]$ sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
[kadmin@k8s-master-1 ~]$ sudo chown $(id -u):$(id -g) $HOME/.kube/config
[kadmin@k8s-master-1 ~]$

Maintenant, déployons le réseau Pod (interface réseau CNI-conteneur). Dans mon cas, je déploierai le plugin calico en tant que réseau Pod. Veuillez suivre la commande kubectl pour exécuter

[kadmin@k8s-master-1 ~]$ kubectl apply -f https://docs.projectcalico.org/v3.14/manifests/calico.yaml

Une fois le réseau de pods déployé avec succès, ajoutez les deux nœuds maîtres restants au cluster. Copiez simplement la commande du nœud maître à partir de la sortie pour rejoindre le cluster, puis collez-la sur k8s-master-2 et k8s-master-3, des exemples sont indiqués ci-dessous

[kadmin@k8s-master-2 ~]$ sudo kubeadm join vip-k8s-master:8443 --token tun848.2hlz8uo37jgy5zqt  --discovery-token-ca-cert-hash sha256:d035f143d4bea38d54a3d827729954ab4b1d9620631ee330b8f3fbc70324abc5 --control-plane --certificate-key a0b31bb346e8d819558f8204d940782e497892ec9d3d74f08d1c0376dc3d3ef4

La sortie est la suivante:

Comment utiliser Kubeadm pour configurer un cluster Kubernetes hautement disponible

La sortie ci-dessus confirme que k8s-master-3 a également rejoint le cluster avec succès. Vérifions l'état du nœud de la commande kubectl au nœud master-1 et exécutons les commandes suivantes

[kadmin@k8s-master-1 ~]$ kubectl get nodes
NAME           STATUS   ROLES    AGE     VERSION
k8s-master-1   Ready    master   31m     v1.18.6
k8s-master-2   Ready    master   10m     v1.18.6
k8s-master-3   Ready    master   3m47s   v1.18.6
[kadmin@k8s-master-1 ~]$

Parfait, nos trois nœuds maîtres sont tous prêts et ont rejoint le cluster.

Étape 7. Joindre le nœud Worker au cluster Kubernetes

Pour joindre un nœud de travail au cluster, copiez la commande du nœud de travail à partir de la sortie et collez-la sur les deux nœuds de travail. Un exemple est illustré ci-dessous:

[kadmin@k8s-worker-1 ~]$ sudo kubeadm join vip-k8s-master:8443 --token tun848.2hlz8uo37jgy5zqt --discovery-token-ca-cert-hash sha256:d035f143d4bea38d54a3d827729954ab4b1d9620631ee330b8f3fbc70324abc5

[kadmin@k8s-worker-2 ~]$ sudo kubeadm join vip-k8s-master:8443 --token tun848.2hlz8uo37jgy5zqt --discovery-token-ca-cert-hash sha256:d035f143d4bea38d54a3d827729954ab4b1d9620631ee330b8f3fbc70324abc5

La sortie ressemble à ceci:

Comment utiliser Kubeadm pour configurer un cluster Kubernetes hautement disponible

Accédez maintenant au nœud k8s-master-1 et exécutez la commande kubectl pour obtenir le nœud de travail d'état:

[kadmin@k8s-master-1 ~]$ kubectl get nodes
NAME           STATUS   ROLES    AGE     VERSION
k8s-master-1   Ready    master   43m     v1.18.6
k8s-master-2   Ready    master   21m     v1.18.6
k8s-master-3   Ready    master   15m     v1.18.6
k8s-worker-1   Ready    <none>   6m11s   v1.18.6
k8s-worker-2   Ready    <none>   5m22s   v1.18.6
[kadmin@k8s-master-1 ~]$

La sortie ci-dessus confirme que les deux nœuds de travail ont rejoint le cluster et sont dans un état prêt.

Exécutez la commande suivante pour vérifier l'état du déploiement dans l'espace de noms kube-system.

[kadmin@k8s-master-1 ~]$ kubectl get pods -n kube-system

Comment utiliser Kubeadm pour configurer un cluster Kubernetes hautement disponible

Étape 8. Testez la haute disponibilité du cluster Kubernetes

Essayons de nous connecter au cluster à partir d'un ordinateur distant (système CentOS) en utilisant le nom et le port de l'équilibreur de charge. Tout d'abord, sur l'ordinateur distant, nous devons installer le package kubectl. Exécutez la commande suivante pour configurer l'entrepôt de logiciels kubernetes.

cat <<EOF | sudo tee /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://packages.cloud.google.com/yum/repos/kubernetes-el7-\$basearch
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
exclude=kubelet kubeadm kubectl
EOF

$ sudo yum install -y  kubectl --disableexcludes=kubernetes

/etc/hostAjoutez maintenant l'entrée suivante dans le fichier:

192.168.1.45   vip-k8s-master

Créez le répertoire kube et /etc/kubernetes/admin.confcopiez les fichiers du nœud k8s-master-1 vers$HOME/.kube/config

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

Exécutez maintenant la commande "kubectl get nodes",

[kadmin@localhost ~]$ kubectl get nodes
NAME           STATUS   ROLES    AGE    VERSION
k8s-master-1   Ready    master   3h5m   v1.18.6
k8s-master-2   Ready    master   163m   v1.18.6
k8s-master-3   Ready    master   157m   v1.18.6
k8s-worker-1   Ready    <none>   148m   v1.18.6
k8s-worker-2   Ready    <none>   147m   v1.18.6
[kadmin@localhost ~]$

Créons un déploiement appelé nginx-lab avec l'image «nginx», puis exposons le déploiement en tant que service de type «NodePort»

[kadmin@localhost ~]$ kubectl create deployment nginx-lab --image=nginx
deployment.apps/nginx-lab created
[kadmin@localhost ~]$
[kadmin@localhost ~]$ kubectl get deployments.apps nginx-lab
NAME        READY   UP-TO-DATE   AVAILABLE   AGE
nginx-lab   1/1     1            1           59s
[kadmin@localhost ~]$ kubectl get pods
NAME                         READY   STATUS    RESTARTS   AGE
nginx-lab-5df4577d49-rzv9q   1/1     Running   0          68s
test-844b65666c-pxpkh        1/1     Running   3          154m
[kadmin@localhost ~]$

Essayons d'étendre la copie de 1 à 4, exécutez la commande suivante:

[kadmin@localhost ~]$ kubectl scale deployment nginx-lab --replicas=4
deployment.apps/nginx-lab scaled
[kadmin@localhost ~]$
[kadmin@localhost ~]$ kubectl get deployments.apps nginx-lab
NAME        READY   UP-TO-DATE   AVAILABLE   AGE
nginx-lab   4/4     4            4           3m10s
[kadmin@localhost ~]$

Maintenant, pour exposer le déploiement en tant que service, exécutez la commande suivante:

[kadmin@localhost ~]$ kubectl expose deployment nginx-lab --name=nginx-lab --type=NodePort --port=80 --target-port=80
service/nginx-lab exposed
[kadmin@localhost ~]$

Obtenez les détails du port et essayez d'utiliser curl pour accéder au serveur Web nginx

[kadmin@localhost ~]$ kubectl get svc nginx-lab
NAME        TYPE       CLUSTER-IP     EXTERNAL-IP   PORT(S)        AGE
nginx-lab   NodePort   10.102.32.29   <none>        80:31766/TCP   60s
[kadmin@localhost ~]$

Pour accéder au serveur Web nginx, nous pouvons utiliser n'importe quel nœud maître ou nœud de travail IP et port comme "31766"

[kadmin@localhost ~]$ curl http://192.168.1.44:31766

La sortie ressemble à ceci:

Comment utiliser Kubeadm pour configurer un cluster Kubernetes hautement disponible

Parfait, c'est sérieux. Nous avons déployé avec succès un cluster Kubernetes haute disponibilité à l'aide de kubeadm sur des serveurs CentOS 7.

Auteur: Pradeep Kumar Traducteur: Yue Yong
Original de: https://www.linuxtechi.com/setup-highly-available-kubernetes-cluster-kubeadm

Je suppose que tu aimes

Origine blog.51cto.com/mageedu/2546879
conseillé
Classement
du quotidien
Plus
2024-06-10(0)
2024-06-09(0)
2024-06-08(0)
2024-06-07(0)
2024-06-06(0)
2024-06-05(0)
2024-06-04(2)
2024-06-03(0)
2024-06-02(1)
2024-06-01(0)

Code World

© 2018 codetd.com