Búsqueda de sitios web

Configure el clúster de Kubernetes en Ubuntu 18.04 usando kubeadm


En esta guía, lo guiaré a través de los pasos para instalar y configurar un clúster Kubernetes de 3 nodos que funcione en Ubuntu 18.04 Bionic Beaver Linux. Kubernetes es un sistema de orquestación de contenedores de código abierto que se utiliza para automatizar la implementación, la gestión y el escalado de aplicaciones en contenedores.

En este artículo compartimos en detalle el proceso de

  • Preparando nodos de Kubernetes
  • Configuración de repositorios
  • Instalación del motor de ejecución de contenedores
  • Instalación de componentes de Kubernetes
  • Arrancando su clúster
  • instalación del complemento de red para Kubernetes
  • Unir nuevos nodos trabajadores al clúster

¡Empecemos!

Paso 1: Diagrama de sistemas y nombres de host

Esta configuración se basa en el siguiente diagrama:

Configuremos los nombres de host del sistema antes de continuar con los siguientes pasos:

En el nodo maestro:

Establezca el nombre de host como se muestra a continuación:

sudo hostnamectl set-hostname k8s-master.example.com

En el nodo trabajador 01:

Establezca el nombre de host usando la herramienta de línea de comando hostamectl.

sudo hostnamectl set-hostname k8s-node-01.example.com

En el nodo trabajador 02:

También establezca el nombre de host para el nodo trabajador 02 de Kubernetes.

sudo hostnamectl set-hostname k8s-node-02.example.com

Una vez que se haya configurado el nombre de host correcto en cada host, complete cada nodo con los valores configurados.

$ sudo vim /etc/hosts
192.168.2.2 k8s-master.example.com k8s-master
192.168.2.3 k8s-node-01.example.com  k8s-node-01
192.168.2.4 k8s-node-02.example.com  k8s-node-02

Cierre sesión y vuelva a iniciarla para usar el nuevo nombre de host configurado.

exit||logout

Paso 2: actualizar el sistema y agregar usuario

Antes de realizar cualquier configuración específica de Kubernetes, asegurémonos de que todos los departamentos estén satisfechos. Aquí haremos una actualización del sistema y crearemos un usuario de Kubernetes.

Actualice los paquetes del sistema a la última versión en todos los nodos:

sudo apt update && sudo apt upgrade -y
[ -e /var/run/reboot-required ] && sudo reboot

Agregue un usuario para administrar el clúster de Kubernetes:

sudo useradd -s /bin/bash -m k8s-admin
sudo passwd k8s-admin
sudo usermod -aG sudo k8s-admin
echo "k8s-admin ALL=(ALL) NOPASSWD:ALL" | sudo tee /etc/sudoers.d/k8s-admin

Si prefiere ingresar la contraseña de sudo cuando ejecuta comandos sudo como usuario k8s-admin, puede ignorar la última línea. Puede probar si no se solicita contraseña para sudo:

$ su - k8s-admin
k8s-admin@k8s-master:~$ sudo su -
root@k8s-master:~# exit

Todo parece bien, procedamos a instalar el motor Docker.

Paso 3: Instale el motor de ejecución en contenedor

Kubernetes requiere un motor de ejecución de contenedores para ejecutar contenedores. En este artículo usaremos Containerd como motor de contenedores.

Asegúrese de que Docker no esté instalado. Si es así, desinstálelo.

sudo apt remove docker docker-engine docker.io

Instalar dependencias:

sudo apt update
sudo apt install apt-transport-https ca-certificates curl software-properties-common

Importar clave GPG del repositorio de Docker:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"

Instalar la ventana acoplable:

sudo apt update && sudo apt install containerd.io

El servicio se inicia automáticamente.

$ systemctl status containerd.service
● containerd.service - containerd container runtime
   Loaded: loaded (/lib/systemd/system/containerd.service; enabled; vendor preset: enabled)
   Active: active (running) since Thu 2023-08-17 09:53:49 UTC; 13s ago
     Docs: https://containerd.io
  Process: 4265 ExecStartPre=/sbin/modprobe overlay (code=exited, status=0/SUCCESS)
 Main PID: 4270 (containerd)
    Tasks: 8
   CGroup: /system.slice/containerd.service
           └─4270 /usr/bin/containerd

Paso 4: instalar los componentes de Kubernetes

Agregue el repositorio APT oficial de Kubernetes.

sudo tee /etc/apt/sources.list.d/kubernetes.list<<EOL
deb http://apt.kubernetes.io/ kubernetes-xenial main
EOL

Luego importe la clave GPG:

curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -

Actualizar el índice del paquete apt:

sudo apt update

Instalar componentes de Kubernetes

Instale kubectl, kubelet, kubernetes-cni y kubeadm los componentes maestros de Kubernetes:

sudo apt install kubectl kubelet kubeadm kubernetes-cni

Confirme que todos los archivos binarios del paquete estén presentes en el sistema de archivos.

$ which kubelet
/usr/bin/kubelet

$ which kubeadm
/usr/bin/kubeadm

Si el intercambio está activado, apáguelo.

sudo swapoff -a
sudo sed -i.bak -r 's/(.+ swap .+)/#\1/' /etc/fstab

Cargue los módulos necesarios.

sudo tee /etc/modules-load.d/containerd.conf <<EOF
overlay
br_netfilter
EOF

Para cargar en tiempo de ejecución, ejecute:

sudo modprobe overlay
sudo modprobe br_netfilter

También establezca las configuraciones de sysctl.

sudo tee /etc/sysctl.d/kubernetes.conf<<EOF
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1
EOF

Cargue las configuraciones.

sudo sysctl --system

Configurar el contenedor y reiniciar el servicio

sudo mkdir -p /etc/containerd
sudo containerd config default|sudo tee /etc/containerd/config.toml
sudo systemctl restart containerd

Habilitar el servicio kubelet

sudo systemctl enable kubelet

Paso 5: Arranque el plano de control de Kubernetes

Todos los comandos que se ejecutarán en esta sección deben ejecutarse en el nodo maestro. No ejecute ninguno de los comandos en los nodos trabajadores de Kubernetes. Los componentes maestros de Kubernetes proporcionan el plano de control del clúster: servidor API, programador y administrador de controladores. Toman decisiones globales sobre el clúster, por ejemplo, programando, detectando y respondiendo a eventos del clúster.

Confirme que Containerd esté funcionando extrayendo imágenes base de Kubernetes.

$ sudo kubeadm config images pull
[config/images] Pulled registry.k8s.io/kube-apiserver:v1.28.0
[config/images] Pulled registry.k8s.io/kube-controller-manager:v1.28.0
[config/images] Pulled registry.k8s.io/kube-scheduler:v1.28.0
[config/images] Pulled registry.k8s.io/kube-proxy:v1.28.0
[config/images] Pulled registry.k8s.io/pause:3.9
[config/images] Pulled registry.k8s.io/etcd:3.5.9-0
[config/images] Pulled registry.k8s.io/coredns/coredns:v1.10.1

Si tiene varios enchufes CRI, utilice --cri-socket para seleccionar uno:

# Containerd
sudo kubeadm config images pull --cri-socket unix:///run/containerd/containerd.sock

# For CRI-O
sudo kubeadm config images pull --cri-socket unix:///var/run/crio/crio.sock

Bootstrap sin punto final compartido

Para iniciar un clúster sin utilizar el punto final DNS, ejecute:

sudo sysctl -p
sudo kubeadm init \
  --pod-network-cidr=172.24.0.0/16 \
  --cri-socket unix:///run/containerd/containerd.sock

Bootstrap con punto final compartido (nombre DNS para la API del plano de control)

Establezca el nombre DNS del punto final del clúster o agregue un registro al archivo /etc/hosts.

$ sudo vim /etc/hosts
172.29.20.5 k8s-cluster.computingforgeeks.com

Crear clúster:

sudo sysctl -p
sudo kubeadm init \
  --pod-network-cidr=172.24.0.0/16 \
  --upload-certs \
  --control-plane-endpoint=k8s-cluster.computingforgeeks.com

Si todo va bien, debería recibir un mensaje de éxito con las instrucciones sobre qué hacer a continuación:

---
Your Kubernetes master has initialized successfully!

To start using your cluster, you need to run the following as a regular user:

  mkdir -p $HOME/.kube
  sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
  sudo chown $(id -u):$(id -g) $HOME/.kube/config

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/

You can now join any number of machines by running the following on each node
as root:

  kubeadm join 192.168.2.2:6443 --token 9y4vc8.h7jdjle1xdovrd0z --discovery-token-ca-cert-hash sha256:cff9d1444a56b24b4a8839ff3330ab7177065c90753ef3e4e614566695db273c

Configurar el acceso para el usuario k8s-admin en el servidor maestro

Cambie a k8s-adminy copie el archivo de configuración de Kubernetes con la información del clúster.

sudo su - k8s-admin
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

Valide la implementación verificando la información del clúster.

$ kubectl cluster-info
Kubernetes control plane is running at https://192.168.2.2:6443
CoreDNS is running at https://192.168.2.2:6443/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy

To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.

Paso 6: implementar la red POD en el clúster

En esta guía usaremos Calico. Puede elegir cualquier otro complemento de red compatible.

Descargue archivos de operadores y recursos personalizados. Consulte la página de lanzamientos para conocer la última versión.

VERSION=v3.26.1
curl -O https://raw.githubusercontent.com/projectcalico/calico/${VERSION}/manifests/tigera-operator.yaml
curl -O https://raw.githubusercontent.com/projectcalico/calico/${VERSION}/manifests/custom-resources.yaml 

Primero, instale el operador en su clúster.

k8s-admin@k8s-master:~$ kubectl create -f tigera-operator.yaml
namespace/tigera-operator created
customresourcedefinition.apiextensions.k8s.io/bgpconfigurations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/bgpfilters.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/bgppeers.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/blockaffinities.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/caliconodestatuses.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/clusterinformations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/felixconfigurations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/globalnetworkpolicies.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/globalnetworksets.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/hostendpoints.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ipamblocks.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ipamconfigs.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ipamhandles.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ippools.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ipreservations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/kubecontrollersconfigurations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/networkpolicies.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/networksets.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/apiservers.operator.tigera.io created
customresourcedefinition.apiextensions.k8s.io/imagesets.operator.tigera.io created
customresourcedefinition.apiextensions.k8s.io/installations.operator.tigera.io created
customresourcedefinition.apiextensions.k8s.io/tigerastatuses.operator.tigera.io created
serviceaccount/tigera-operator created
clusterrole.rbac.authorization.k8s.io/tigera-operator created
clusterrolebinding.rbac.authorization.k8s.io/tigera-operator created
deployment.apps/tigera-operator created

Actualicemos también Calico IP Pool.

sed -ie 's/192.168.0.0/172.24.0.0/g' custom-resources.yaml

Luego aplique las configuraciones del manifiesto.

k8s-admin@k8s-master:~$  kubectl create -f custom-resources.yaml
installation.operator.tigera.io/default created
apiserver.operator.tigera.io/default created

Espere a que Calico Pod esté en estado de ejecución.

k8s-admin@k8s-master:~$ kubectl get pods --all-namespaces
NAMESPACE          NAME                                             READY   STATUS    RESTARTS   AGE
calico-apiserver   calico-apiserver-5476c484c4-rmmts                1/1     Running   0          37s
calico-apiserver   calico-apiserver-5476c484c4-z9phf                1/1     Running   0          37s
calico-system      calico-kube-controllers-6945f87bd4-2xwx4         1/1     Running   0          80s
calico-system      calico-node-tkwtv                                1/1     Running   0          80s
calico-system      calico-typha-65f575c9fc-xx8m8                    1/1     Running   0          81s
calico-system      csi-node-driver-kngdn                            2/2     Running   0          80s
kube-system        coredns-5dd5756b68-77x77                         1/1     Running   0          11m
kube-system        coredns-5dd5756b68-plpd6                         1/1     Running   0          11m
kube-system        etcd-k8s-master.example.com                      1/1     Running   0          11m
kube-system        kube-apiserver-k8s-master.example.com            1/1     Running   0          11m
kube-system        kube-controller-manager-k8s-master.example.com   1/1     Running   0          11m
kube-system        kube-proxy-bxq4x                                 1/1     Running   0          11m
kube-system        kube-scheduler-k8s-master.example.com            1/1     Running   0          11m
tigera-operator    tigera-operator-94d7f7696-xls25                  1/1     Running   0          3m20s

El nodo ahora debería estar listo.

k8s-admin@k8s-master:~$ kubectl get nodes
NAME                     STATUS   ROLES           AGE   VERSION
k8s-master.example.com   Ready    control-plane   20m   v1.28.0

Paso 7: configurar los nodos trabajadores de Kubernetes

Cuando el clúster de Kubernetes se haya inicializado y el nodo maestro esté en línea, inicie la configuración de los nodos trabajadores. Un nodo es una máquina trabajadora en Kubernetes, puede ser una máquina virtual o una máquina física. Cada nodo es administrado por el maestro y tiene los servicios necesarios para ejecutar pods: docker, kubelet, kube-proxy.

1) Asegúrese de que el tiempo de ejecución de Containerd esté instalado (cubierto)

Utilice los pasos proporcionados en este artículo sobre la instalación de contenedores

2) Agregar el repositorio de Kubernetes (cubierto)

Asegúrese de que el repositorio de paquetes de Kubernetes esté agregado al sistema.

3) Instale los componentes de Kubernetes (Paso 4)

Una vez que haya agregado el repositorio de Kubernetes, instale los componentes usando:

sudo apt install kubelet kubeadm kubectl kubernetes-cni

4) Unir el Nodo al Clúster:

Utilice el comando de unión proporcionado después de inicializar el clúster de Kubernetes. Puede imprimir los comandos usando:

kubeadm token create --print-join-command

Cuando termine, verifique el estado de los nodos en el maestro:

k8s-admin@k8s-master:~$ kubectl get nodes
NAME          STATUS    ROLES     AGE       VERSION
k8s-master    Ready     master    35m       v1.11.0
k8s-node-01   Ready     <none>    2m        v1.11.0
k8s-node-02   Ready     <none>    1m        v1.11.0

En los dos nodos, se debe configurar Weave Net.

root@k8s-node-01:~# ip ad | grep weave
6: weave: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1376 qdisc noqueue state UP group default qlen 1000
    inet 10.44.0.0/12 brd 10.47.255.255 scope global weave
9: vethwe-bridge@vethwe-datapath: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1376 qdisc noqueue master weave state UP group default

root@k8s-node-02:~# ip ad | grep weave
6: weave: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1376 qdisc noqueue state UP group default qlen 1000
    inet 10.47.0.0/12 brd 10.47.255.255 scope global weave
9: vethwe-bridge@vethwe-datapath: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1376 qdisc noqueue master weave state UP group default

Paso 8: Probar la implementación de Kubernetes

Cree un espacio de nombres de prueba:

$ kubectl create namespace test
namespace/test created

Implementar aplicación de prueba

kubectl create deployment hello-node --image=registry.k8s.io/e2e-test-images/agnhost:2.39 -- /agnhost netexec --http-port=8080

Ver implementaciones existentes:

$ kubectl get deployments
NAME         READY   UP-TO-DATE   AVAILABLE   AGE
hello-node   1/1     1            1           1m

Ver pods de carrera

$ kubectl get pods
NAME                          READY     STATUS    RESTARTS   AGE
hello-node-5f76cf6ccf-br9b5   1/1       Running   0          1m

Para limpiar recursos ejecute:

kubectl delete deployment hello-node

Paso 9: configurar la finalización de kubectl

Habilite el autocompletado de shell para los comandos de kubectl. kubectl incluye soporte de autocompletado, lo que puede ahorrar mucho tiempo de escritura. Para habilitar la finalización del shell en su sesión actual, ejecute:

source <(kubectl completion bash)

Para agregar el autocompletado de kubectl a su perfil, para que se cargue automáticamente en futuros shells, ejecute:

echo "source <(kubectl completion bash)" >> ~/.bashrc

Si está utilizando zsh, edite el archivo ~/.zshrc y agregue el siguiente código para habilitar el autocompletado de kubectl:

if [ $commands[kubectl] ]; then
source <(kubectl completion zsh)
fi

O cuando utilice Oh-My-Zsh, edite el archivo ~/.zshrc y actualice la línea plugins= para incluir el complemento kubectl.

source <(kubectl completion zsh)

También es relevante el comando Superior para métricas de contenedores.

Materiales de formación para el dominio de Kubernetes:

  • Los mejores libros de estudio de Kubernetes

Conclusión

Hemos implementado con éxito un clúster Kubernetes de 3 nodos en servidores Ubuntu 18.04 LTS. Nuestras próximas guías cubrirán Kubernetes HA, Kubernetes Monitoring, cómo configurar el almacenamiento externo y más cosas interesantes. ¡Manténganse al tanto!.