Cómo utilizar Kubeadm para configurar un clúster de Kubernetes de alta disponibilidad

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

Cuando configuramos un clúster de Kubernetes (k8s) localmente para el entorno de producción, se recomienda implementarlo con alta disponibilidad. Alta disponibilidad significa instalar un nodo maestro de Kubernetes o un nodo trabajador en HA. En este artículo, demostraré cómo configurar un clúster de Kubernetes de alta disponibilidad mediante la utilidad kubeadm.

Para demostrarlo, utilicé cinco sistemas CentOS 7 con los siguientes detalles:

  • k8s-master-1 - mínimo CentOS 7 - 192.168.1.40 - 2 GB de RAM, 2 vCPU, 40 GB de disco
  • k8s-master-2 - mínimo CentOS 7 - 192.168.1.41 - 2 GB de RAM, 2 vCPU, 40 GB de disco
  • k8s-master-3 - mínimo CentOS 7 - 192.168.1.42 - 2 GB de RAM, 2 vCPU, 40 GB de disco
  • k8s-worker-1 - mínimo CentOS 7 - 192.168.1.43 - 2 GB de RAM, 2 vCPU, 40 GB de disco
  • k8s-worker-2 - mínimo CentOS 7 - 192.168.1.44 - 2 GB de RAM, 2 vCPU, 40 GB de disco

Cómo utilizar Kubeadm para configurar un clúster de Kubernetes de alta disponibilidad

Nota: El clúster etcd también se puede formar fuera del nodo maestro, pero para esto necesitamos hardware adicional, así que instalé etcd en el nodo maestro.

Establezca los requisitos mínimos para la alta disponibilidad del clúster de K8:

  • Instale Kubeadm, kubelet y kubectl en todos los nodos maestros y trabajadores
  • Conexión de red entre el nodo maestro y el nodo trabajador
  • Conexión a Internet en todos los nodos
  • Credenciales raíz o usuario privilegiado sudo en todos los nodos

Saltemos los pasos de instalación y configuración.

Paso 1. Configure el nombre de host y agregue entradas en el archivo / etc / hosts

Ejecute el hostnamectlcomando para establecer el nombre de host en cada nodo. Por ejemplo, el ejemplo muestra el nodo principal de K8s:

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

De manera similar, ejecute los comandos anteriores en los nodos restantes y configure sus respectivos nombres de host. Después de configurar los nombres de host en todos los nodos maestros y nodos de trabajo /etc/hosts, agregue las siguientes entradas en los archivos de todos los nodos .

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

Usé otra entrada "192.168.1.45 vip-k8s-master" en el archivo de hosts porque usaré esta IP y el nombre de host al configurar haproxy y permanecer conectado en todos los nodos maestros. Esta IP se utilizará como la IP del balanceador de carga de kube-apiserver. Todas las solicitudes de kube-apiserver llegarán a esta IP, y luego las solicitudes se distribuirán a los nodos de kube-apiserver reales en el backend.

Paso 2. Instale y configure Keepalive y HAProxy en todos los nodos maestro / trabajador

Utilice los siguientes yumcomandos para instalar keepalived y haproxy en cada nodo maestro:

$ sudo yum install haproxy keepalived -y

Primero, configure Keepalived en k8s-master-1, el check_apiserver.shscript de creación obtendrá el siguiente contenido:

[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

Guarde y salga del archivo, configure los permisos ejecutables:

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

Haga una copia de seguridad del keepalived.confarchivo y luego vacíelo.

[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'

Ahora pega lo siguiente en el /etc/keepalived/keepalived.confarchivo

[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
    }
}

Guarde y cierre el archivo.

Nota: Para los nodos master-2 y 3, solo es necesario cambiar dos parámetros de este archivo. El estado de los nodos maestros 2 y 3 cambiará a la SLAVEprioridad 254 y 253 respectivamente.

Configure HAProxy en el nodo k8s-master-1, edite su archivo de configuración y agregue el siguiente contenido:

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

Elimine todas las líneas después de la sección predeterminada y agregue las siguientes líneas

[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

Guardar y salir del archivo.

Cómo utilizar Kubeadm para configurar un clúster de Kubernetes de alta disponibilidad

Ahora copie estos tres archivos (check_apiserver.sh, keepalived.conf y haproxy.cfg) de k8s-master-1 a k8s-master-2 y 3

Ejecute el siguiente bucle for para copiar estos archivos scp al master 2 y 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

Nota: No olvide cambiar keepalived.conflos dos parámetros en el archivo que discutimos anteriormente para k8s-master-2 y 3 .

Si el firewall se está ejecutando en el nodo principal, agregue las siguientes reglas de firewall en los tres nodos principales

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

Ahora, inicie y habilite los servicios keepalived y haproxy en los tres nodos maestros usando los siguientes comandos:

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

Después de que estos servicios se inicien correctamente, verifique si se ha habilitado VIP (IP virtual) en el nodo k8s-master-1, porque hemos marcado k8s-master-1 como el nodo MASTER en el archivo de configuración keepalived.

Cómo utilizar Kubeadm para configurar un clúster de Kubernetes de alta disponibilidad

Perfecto, la salida anterior confirma que VIP se ha habilitado en k8s-master-1.

Paso 3. Deshabilite la partición de intercambio y configure SELinux como las reglas de permisos y reglas de firewall para los nodos primario y secundario.

Para deshabilitar el espacio de intercambio en todos los nodos (incluidos los nodos de trabajo), ejecute el siguiente comando:

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

Establezca SELinux en Permissive en todos los nodos maestros y nodos de trabajo, y ejecute el siguiente comando,

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

Reglas de firewall del nodo maestro:

Si el firewall se está ejecutando en el nodo principal, se permiten los siguientes puertos en el firewall

Cómo utilizar Kubeadm para configurar un clúster de Kubernetes de alta disponibilidad

Ejecute el siguiente comando firewall-cmd en todos los nodos maestros:

$ 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"

Reglas de firewall para nodos de trabajo:

Si el firewall se está ejecutando en los nodos trabajadores, permita los siguientes puertos en el firewall en todos los nodos trabajadores

Cómo utilizar Kubeadm para configurar un clúster de Kubernetes de alta disponibilidad

Ejecute el siguiente comando en todos los nodos trabajadores:

$ 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"

Paso 4. Instale Container Operation (CRI) Docker en los nodos maestro y trabajador

Instale Docker en todos los nodos maestros y trabajadores, ejecute el siguiente comando

$ 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

Ejecute el siguiente comando systemctl para iniciar y habilitar el servicio Docker (también ejecute este comando en todos los nodos maestros y trabajadores)

$ sudo systemctl enable docker --now

Ahora, instalemos kubeadm, kubelet y kubectl en el siguiente paso

Paso 5. Instale Kubeadm, kubelet y kubectl

Instale kubeadm, kubelet y kubectl en todos los nodos primarios y secundarios. Antes de instalar estos paquetes primero, debemos configurar el repositorio del repositorio de Kubernetes y ejecutar los siguientes comandos en cada nodo maestro y nodo trabajador

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

Ahora, ejecute bajo el comando yum para instalar estos paquetes

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

Ejecute el siguiente comando systemctl para habilitar el servicio kubelet en todos los nodos (nodos maestro y trabajador)

$ sudo systemctl enable kubelet --now

Paso 6. Inicialice el clúster de Kubernetes desde el primer nodo principal

Ahora vaya al primer terminal del nodo maestro y ejecute el siguiente comando

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

En el comando anterior, se establecen --control-plane-endpointel nombre dns y el puerto del balanceador de carga (kube-apiserver). En mi caso, el nombre dns es "vip-k8s-master" y el puerto es "8443", excepto que esta --upload-certsopción será automáticamente Comparta certificados entre nodos maestros.

La salida del comando kubeadm es la siguiente:

Cómo utilizar Kubeadm para configurar un clúster de Kubernetes de alta disponibilidad

Genial, el resultado anterior confirma que el clúster de Kubernetes se ha inicializado correctamente. En el resultado, también obtuvimos comandos para que otros nodos maestros y nodos trabajadores se unieran al clúster.

Nota: se recomienda copiar esta salida a un archivo de texto para referencia futura.

Ejecute el siguiente comando para permitir que los usuarios locales interactúen con el clúster mediante los comandos 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 ~]$

Ahora, implementemos la red Pod (interfaz de red CNI-container). En mi caso, implementaré el complemento calico como una red Pod. Siga el comando kubectl para ejecutar

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

Después de implementar con éxito la red de pod, agregue los dos nodos maestros restantes al clúster. Simplemente copie el comando para el nodo maestro de la salida para unirse al clúster y luego péguelo en k8s-master-2 y k8s-master-3, los ejemplos se muestran a continuación

[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

El resultado es el siguiente:

Cómo utilizar Kubeadm para configurar un clúster de Kubernetes de alta disponibilidad

El resultado anterior confirma que k8s-master-3 también se ha unido con éxito al clúster. Verifiquemos el estado del nodo desde el comando kubectl hasta el nodo master-1 y ejecutemos los siguientes comandos

[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 ~]$

Perfecto, nuestros tres nodos maestros están listos y se unieron al clúster.

Paso 7. Unir el nodo trabajador al clúster de Kubernetes

Para unir un nodo trabajador al clúster, copie el comando del nodo trabajador de la salida y péguelo en ambos nodos trabajadores. A continuación, se muestra un ejemplo:

[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

El resultado es el siguiente:

Cómo utilizar Kubeadm para configurar un clúster de Kubernetes de alta disponibilidad

Ahora vaya al nodo k8s-master-1 y ejecute bajo el comando kubectl para obtener el nodo trabajador de estado:

[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 ~]$

El resultado anterior confirma que ambos nodos de trabajo se han unido al clúster y están listos.

Ejecute el siguiente comando para verificar el estado de implementación en el espacio de nombres del sistema kube.

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

Cómo utilizar Kubeadm para configurar un clúster de Kubernetes de alta disponibilidad

Paso 8. Pruebe la alta disponibilidad del clúster de Kubernetes

Intentemos conectarnos al clúster desde una computadora remota (sistema CentOS) usando el nombre y el puerto dns del balanceador de carga. Primero, en la computadora remota, debemos instalar el paquete kubectl. Ejecute el siguiente comando para configurar el almacén de software de 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

Ahora /etc/hostagregue la siguiente entrada en el archivo:

192.168.1.45   vip-k8s-master

Cree el directorio kube y /etc/kubernetes/admin.confcopie los archivos del nodo k8s-master-1 a$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

Ahora ejecute el comando "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 ~]$

Creemos una implementación llamada nginx-lab con la imagen "nginx", y luego expongamos la implementación como un servicio de tipo "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 ~]$

Intentemos expandir la copia de 1 a 4, ejecute el siguiente comando:

[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 ~]$

Ahora, para exponer la implementación como un servicio, ejecute el siguiente comando:

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

Obtenga los detalles del puerto e intente usar curl para acceder al servidor 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 ~]$

Para acceder al servidor web nginx, podemos usar cualquier IP y puerto de nodo maestro o nodo de trabajo como "31766"

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

El resultado es el siguiente:

Cómo utilizar Kubeadm para configurar un clúster de Kubernetes de alta disponibilidad

Perfecto, esto es serio. Hemos implementado con éxito un clúster de Kubernetes de alta disponibilidad utilizando kubeadm en servidores CentOS 7.

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

Supongo que te gusta

Origin blog.51cto.com/mageedu/2546879
Recomendado
Clasificación
Diario
Más
2024-05-15(5)
2024-05-14(10)
2024-05-13(7)
2024-05-12(22)
2024-05-11(31)
2024-05-10(32)
2024-05-09(31)
2024-05-08(18)
2024-05-07(35)
2024-05-06(4)

Code World

© 2018 codetd.com