Cómo configurar un clúster de Kubernetes con Kubeadm en Ubuntu 22.04

Kubernetes o k8s es una plataforma de código abierto para la orquestación de contenedores que automatiza el despliegue, la gestión y el escalado de las aplicaciones en contenedores. Kubernetes es una orquestación de contenedores creada por Google, y ahora se ha convertido en un proyecto de código abierto y se ha convertido en un estándar para el despliegue de aplicaciones modernas y plataformas informáticas.

Kubernetes es la solución para la era moderna de despliegue de contenedores. Proporciona descubrimiento de servicios y equilibrio de carga, orquestación de almacenamiento, despliegue y retroceso automatizados, servicio de autorreparación, secreto y gestión de la configuración. Kubernetes permite un desarrollo nativo en la nube rentable.

En este tutorial, configurarás el clúster de Kubernetes mediante:

1. Configurar los sistemas, lo que incluye: configurar el archivo /etc/hosts, habilitar los módulos del núcleo y deshabilitar el SWAP.
2. Configurar el cortafuegos UFW añadiendo algunos puertos necesarios para Kubernetes.
3. Instalar containerd como tiempo de ejecución de contenedores para Kubernetes.
4. Instalar paquetes de Kubernetes como kubelet, kubeadm y kubectl.
5. Instalar el plugin de red Flannel para Kubernetes Pods.
6. Inicializar un nodo del plano de control y añadir dos nodos trabajadores.

Requisitos previos

Para completar este tutorial, necesitarás los siguientes requisitos:

• Tres o más servidores Ubuntu 22.04.
• Un usuario no root con privilegios de root/administrador.

Configuración de los sistemas

Antes de empezar a instalar cualquier paquete para el despliegue de Kubernetes, tendrás que configurar todos tus sistemas como se requiere para el despliegue de Kubernetes. Esto incluye las siguientes configuraciones:

• Configurarcorrectamente el archivo /etc/hosts: Cada nombre de host del servidor debe ser resuelto a la dirección IP correcta. Esto puede hacerse de varias maneras, pero la más fácil y sencilla es utilizar el archivo /etc/hosts en todos los servidores.
• Configura el cortafuegos UFW: Para el entorno de producción, siempre se recomienda habilitar el cortafuegos tanto en el plano de control como en los nodos trabajadores.
• Habilita los Módulos del kernel: Kubernetes requiere que se habiliten algunos módulos del kernel en el sistema Linux. El módulo del kernel«overlay» y«br_netfilter» son necesarios para que iptables pueda ver el tráfico en puente.
• Desactivar SWAP: Esto es obligatorio, debes desactivar SWAP en todos los nodos de Kubernetes, tanto en el plano de control como en los nodos trabajadores. De lo contrario, el servicio kubelet funcionará con problemas.

Configurar el archivo /etc/hosts

En este primer paso, configurarás el nombre de host del sistema y el archivo /etc/hosts en todos tus servidores. Para esta demostración, utilizaremos los siguientes servidores.

Hostname    IP Address        Used as
--------------------------------------------
cplane1     192.168.5.10      control-plane
worker1     192.168.5.25      worker node
worker2     192.168.5.26      worker node

Ejecuta el siguiente comando hostnamectl para configurar el nombre de host del sistema en cada servidor.

Para el nodo del plano de control, ejecuta el siguiente comando para configurar el nombre de host del sistema como«cplane1«.

sudo hostnamectl set-hostname cplane1

Para los nodos trabajadores de Kubernetes, ejecuta el siguiente comando hostnamectl.

# setup hostname worker1
sudo hostnamectl set-hostname worker1

# setup hostname worker2
sudo hostnamectl set-hostname worker2

A continuación, modifica el archivo /etc/hosts en todos los servidores con el siguiente comando.

sudo nano /etc/hosts

Añade la siguiente configuración al archivo. Asegúrate de que cada nombre de host apunta a la dirección IP correcta.

192.168.5.10 cplane1
192.168.5.25 worker1
192.168.5.26 worker2

Guarda y cierra el archivo cuando hayas terminado.

Por último, si ejecutas el comando ping contra cada nombre de host, se apuntará a la dirección IP correcta definida en el archivo /etc/hosts.

ping cplane1 -c3
ping worker1 -c3
ping worker2 -c3

Configurar el cortafuegos UFW

Kubernetes requiere que algunos puertos estén abiertos en todos tus sistemas. En el sistema Ubuntu por defecto, se utiliza el cortafuegos UFW como cortafuegos por defecto. Añadirás algunos puertos al cortafuegos UFW para el despliegue de Kubernetes.

Para el plano de control de Kubernetes, tienes que abrir los siguientes puertos:

Protocol  Direction Port Range  Purpose Used By
-----------------------------------------------
TCP       Inbound   6443        Kubernetes API server All
TCP       Inbound   2379-2380   etcd server client API  kube-apiserver, etcd
TCP       Inbound   10250       Kubelet API Self, Control plane
TCP       Inbound   10259       kube-scheduler  Self
TCP       Inbound   10257       kube-controller-manager Self

Para los nodos trabajadores de Kubernetes, necesitas abrir los siguientes puertos:

Protocol  Direction Port Range  Purpose Used By
--------------------------------------------------
TCP       Inbound   10250       Kubelet API Self, Control plane
TCP       Inbound   30000-32767 NodePort Services†  All

Antes de añadir reglas UFW, asegúrate de añadir la aplicación OpenSSH a tu cortafuegos mediante el siguiente comando. A continuación, activa el cortafuegos UFW. Cuando se te pida confirmación, introduce«y» para habilitar y ejecutar el cortafuegos UFW.

sudo ufw allow "OpenSSH"
sudo ufw enable

En el nodo del plano de control«cplane1«, ejecuta el siguiente comando ufw para abrir los puertos.

sudo ufw allow 6443/tcp
sudo ufw allow 2379:2380/tcp
sudo ufw allow 10250/tcp
sudo ufw allow 10259/tcp
sudo ufw allow 10257/tcp

sudo ufw status

En los nodos trabajadores «worker1″ y«worker2«, ejecuta el siguiente comando ufw para abrir algunos puertos.

sudo ufw allow 10250/tcp
sudo ufw allow 30000:32767/tcp

sudo ufw status

Habilita los módulos del núcleo y desactiva el SWAP

Kubernetes requiere que los módulos del kernel«overlay» y«br_netfilter» estén habilitados en todos los servidores. Esto permitirá a los iptbales ver los tráficos en puente. Además, tendrás que habilitar el reenvío de puertos y desactivar el SWAP.

Ejecuta el siguiente comando para habilitar los módulos del kernel«overlay» y«br_netfilter«.

sudo modprobe overlay
sudo modprobe br_netfilter

Para hacerlo permanente, crea el archivo de configuración en«/etc/modules-load.d/k8s.conf«. Esto permitirá a los sistemas Linux habilitar los módulos del núcleo durante el arranque del sistema.

cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
overlay
br_netfilter
EOF

A continuación, crea los parámetros de systemctl necesarios mediante el siguiente comando.

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

Para aplicar la nueva configuración de sysctl sin reiniciar el sistema, utiliza el siguiente comando. Deberás obtener la lista de parámetros sysctl por defecto en tu sistema y asegurarte de que obtienes los parámetros sysctl que acabas de añadir en el archivo«k8s.conf«.

sudo sysctl --system

Para desactivar el SWAP, tendrás que comentar la configuración del SWAP en el archivo«/etc/fstab«. Esto puede hacerse utilizando el comando único mediante sed (editor de flujos) o editando manualmente el archivo /etc/fstab.

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

o

sudo nano /etc/fstab

Ahora desactiva el SWAP en la sesión actual utilizando el siguiente comando. A continuación, comprueba que el SWAP está apagado utilizando el comando«free -m«. Deberías ver que el SWAP tiene valores«0», lo que significa que ahora está desactivado.

sudo swapoff -a
free -m

Instalar el tiempo de ejecución del contenedor: Containerd

Para configurar el Cluster Kubernetes, debes instalar el tiempo de ejecución de contenedores en todos los servidores para que los Pods puedan ejecutarse. Se pueden utilizar varios tiempos de ejecución de contenedores para los despliegues de Kubernetes, como containerd, CRI-O, Mirantis Container Runtime y Docker Engine (a través de cri-dockerd).

En esta demostración, utilizaremos «containerd» como contenedor para nuestro despliegue de Kubernetes. Por lo tanto, instalarás containerd en todos los servidores, el plano de control y los nodos trabajadores.

Hay varias formas de instalar containerd, la más sencilla es utilizar los paquetes binarios preconstruidos que proporciona el repositorio de Docker.

Ahora ejecuta el siguiente comando para añadir el repositorio Docker y la clave GPG.

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker.gpg
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Actualiza y refresca el índice de paquetes en tu sistema ubuntu utilizando el siguiente comando.

sudo apt update

Ahora instala el paquete containerd utilizando el siguiente comando apt. Y comenzará la instalación.

sudo apt install containerd.io

Una vez terminada la instalación, ejecuta el siguiente comando para detener el servicio containerd.

sudo systemctl stop containerd

Haz una copia de seguridad de la configuración predeterminada de containerd y genera una nueva con el siguiente comando.

sudo mv /etc/containerd/config.toml /etc/containerd/config.toml.orig
sudo containerd config default > /etc/containerd/config.toml

Ahora modifica el archivo de configuración de containerd«/etc/containerd/config.toml» utilizando el siguiente comando.

sudo nano /etc/containerd/config.toml

Cambia el valor del controlador cgroup«SystemdCgroup = false» por«SystemdCgroup = true«. Esto habilitará el controlador cgroup de systemd para el tiempo de ejecución del contenedor containerd.

[plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runc]
  ...
  [plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runc.options]
    SystemdCgroup = true

Cuando hayas terminado, guarda y cierra el archivo.

A continuación, ejecuta el siguiente comando systemctl para iniciar el servicio containerd.

sudo systemctl start containerd

Por último, comprueba y verifica el servicio containerd con el siguiente comando. Deberías ver que containerd está habilitado y se ejecutará automáticamente al arrancar el sistema. Y el estado actual del servicio containerd es de ejecución.

sudo systemctl is-enabled containerd
sudo systemctl status containerd

Instalación del paquete Kubernetes

Has instalado el tiempo de ejecución del contenedor containerd. Ahora vas a instalar los paquetes de Kubernetes en todos tus sistemas Ubuntu. Esto incluye el kubeadm para arrancar el cluster de Kubernetes, el kubelet el componente principal del cluster de Kubernetes, y el kubectl la utilidad de línea de comandos para gestionar el cluster de Kubernetes.

En este ejemplo, instalaremos los paquetes de Kubernetes utilizando el repositorio proporcionado por Kubernetes. Por tanto, añadirás el repositorio de Kubernetes a todos tus sistemas ubuntu.

Ejecuta el siguiente comando apt para instalar algunas dependencias de los paquetes.

sudo apt install apt-transport-https ca-certificates curl -y

Ahora añade el repositorio de Kubernetes y la clave GPG utilizando el siguiente comando.

sudo curl -fsSLo /usr/share/keyrings/kubernetes-archive-keyring.gpg https://packages.cloud.google.com/apt/doc/apt-key.gpg
echo "deb [signed-by=/usr/share/keyrings/kubernetes-archive-keyring.gpg] https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list

Actualiza y refresca tu repositorio de Ubuntu y el índice de paquetes.

sudo apt update

Cuando termine la actualización, instala los paquetes de Kubernetes utilizando el siguiente comando apt. Introduce Y para confirmar la instalación y pulsa ENTER para continuar, y la instalación comenzará.

sudo apt install kubelet kubeadm kubectl

Una vez finalizada la instalación, ejecuta el siguiente comando para fijar la versión actual de los paquetes de Kubernetes. Esto evitará que los paquetes de Kubernetes se actualicen automáticamente y evitará el desajuste de versiones entre los paquetes de Kubernetes.

sudo apt-mark hold kubelet kubeadm kubectl

Instalación del plugin CNI (Container Network Interface): Flannel

Kubernetes admite varios plugins de red de contenedores, como AWS VPC para Kubernetes, Azure CNI, Cilium, Calico, Flannel y muchos más. En este ejemplo, utilizaremos Flannel como plugin CNI para el despliegue de Kubernetes. Para ello es necesario instalar el archivo binario de Flannel en los nodos de Kubernetes.

Ejecuta el siguiente comando para crear un nuevo directorio«/opt/bin«. A continuación, descarga el archivo binario de Flannel en él.

mkdir -p /opt/bin/
sudo curl -fsSLo /opt/bin/flanneld https://github.com/flannel-io/flannel/releases/download/v0.19.0/flanneld-amd64

Ahora haz que el archivo binario «flanneld» sea ejecutable cambiando el permiso del archivo mediante el siguiente comando. Este archivo binario «flanneld» se ejecutará automáticamente cuando configures el complemento de red Pod.

sudo chmod +x /opt/bin/flanneld

Inicializar el plano de control de Kubernetes

Has finalizado todas las dependencias y requisitos para desplegar el Cluster de Kubernetes. Ahora vas a iniciar el Cluster de Kubernetes inicializando el nodo del Plano de Control por primera vez. En este ejemplo, el Plano de Control de Kubernetes se instalará en el servidor«cplane1» con la dirección IP«192.168.5.10«.

Antes de inicializar el nodo del Plano de Control, ejecuta el siguiente comando para comprobar que los módulos del kernel«br_netfilter» están habilitados. Si obtienes una salida del comando, significa que el módulo «br_netfilter» está habilitado.

lsmod | grep br_netfilter

A continuación, ejecuta el siguiente comando para descargar las imágenes necesarias para el clúster de Kubernetes. Este comando descargará todas las imágenes de contenedor necesarias para crear el Clúster Kubernetes, como coredns, kube-api server, etcd, kube-controller, kube-proxy y la imagen de contenedor de pausa.

sudo kubeadm config images pull

Una vez finalizada la descarga, ejecuta el siguiente comando«kubeadm init» para inicializar el Cluster Kubernetes en el servidor«cplane1″. Este nodo«cplane1″ se seleccionará automáticamente como Plano de Control de Kubernetes porque es la primera vez que se inicializa el clúster.

• Además, en este ejemplo, especificamos la red para los Pods a«10.244.0.0/16«, que es el rango de red por defecto para el plugin CNI de Flannel.
• La opción «–apiserver-advertise-address» determina en qué dirección IP se ejecutará el servidor de la API de Kubernetes, en este ejemplo se utiliza la dirección IP interna«192.168.5.10«.
• Para la opción«–cri-socket» aquí especificamos el socket CRI al socket de tiempo de ejecución del contenedor que está disponible en «/run/containerd/containerd.sock«. Si utilizas un tiempo de ejecución del contenedor diferente, debes cambiar la ruta del archivo del socket, o simplemente puedes eliminar esta opción «–cri-socket» porque el kubeadm detectará el socket del tiempo de ejecución del contenedor automáticamente.

sudo kubeadm init --pod-network-cidr=10.244.0.0/16 \
--apiserver-advertise-address=192.168.5.10 \
--cri-socket=unix:///run/containerd/containerd.sock

A continuación se muestra la salida cuando se inicializa el Cluster Kubernetes en el servidor«cplane1«.

Cuando termine la inicialización, podrás ver el mensaje«¡Tu plano de control de Kubernetes se ha inicializado con éxito!» con algunos mensajes de salida importantes para la configuración de las credenciales de Kubernetes y el despliegue del complemento de red Pod, la forma de añadir el nodo trabajador a tu Cluster Kubernetes.

Antes de empezar a utilizar el Cluster de Kubernetes, tendrás que configurar las credenciales de Kubernetes. Ejecuta el siguiente comando para configurar las credenciales de Kubernetes.

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

Ahora puedes utilizar el comando «kubectl» para interactuar con tu clúster de Kubernetes. Ejecuta el siguiente comando«kubectl» para comprobar la información del clúster de Kubernetes. Y deberías ver el plano de control de Kubernetes y los coredns en funcionamiento.

kubectl cluster-info

Para obtener toda la información sobre tu Kubernetes, puedes utilizar la opción dump – así«kubectl cluster-info dump«.

Una vez que el plano de control de Kubernetes esté en marcha, ejecuta el siguiente comando para instalar el plugin de red Flannel Pod. Este comando ejecutará automáticamente el archivo binario«flanneld» y ejecutará algunos pods de Flannel.

kubectl apply -f https://raw.githubusercontent.com/flannel-io/flannel/master/Documentation/kube-flannel.yml

Comprueba la lista de pods en ejecución en tu Kubernetes utilizando el siguiente comando. si tu instalación de Kubernetes es correcta, deberías ver que todos los pods principales de Kubernetes están en ejecución.

kubectl get pods --all-namespaces

Añadir nodos trabajadores a Kubernetes

Después de inicializar el Plano de Control de Kubernetes en el servidor«cplane1«, añadirás los nodos trabajadores«worker1» y«worker2» al Cluster de Kubernetes.

Dirígete al servidor «worker1» y ejecuta el siguiente comando«kubeadm join» para añadir el «worker1» al Cluster de Kubernetes. Es posible que tengas un token y un ca-cert-hash diferentes, puedes ver los detalles de esta información en el mensaje de salida al inicializar el nodo del Plano de Control.

kubeadm join 192.168.5.10:6443 --token po3sb1.oux4z76nwb0veuna \
--discovery-token-ca-cert-hash sha256:f5068150fabaf85f3d04e19a395c60d19298ba441e2d9391e20df3267ea6cd28

En el siguiente mensaje de salida, puedes ver que el servidor«worker1» se ha unido al Clúster Kubernetes.

A continuación, pasa al servidor «worker2» y ejecuta el comando«kubeadm join» para añadir el«worker2» al Cluster de Kubernetes.

kubeadm join 192.168.5.10:6443 --token po3sb1.oux4z76nwb0veuna \
--discovery-token-ca-cert-hash sha256:f5068150fabaf85f3d04e19a395c60d19298ba441e2d9391e20df3267ea6cd28

Verás el mismo mensaje de salida cuando termine el proceso.

Ahora vuelve al servidor del Plano de Control «cplane1» y ejecuta el siguiente comando para comprobar todos los pods en ejecución en el Cluster de Kubernetes. Deberías ver que hay pods adicionales en cada componente de Kubernetes.

kubectl get pods --all-namespaces

Por último, comprueba y verifica todos los nodos disponibles en el Cluster de Kubernetes utilizando el comando‘kubectl» que aparece a continuación. Deberías ver que el servidor«cplane1» se está ejecutando como Plano de Control de Kubernetes, y que los servidores«worker1» y«worker2» se están ejecutando como nodo trabajador.

kubectl get nodes -o wide

Conclusión

A lo largo de este tutorial, has finalizado el despliegue del Cluster de Kubernetes con tres nodos de servidores Ubuntu 22.04. El Clúster Kubernetes se está ejecutando con un plano de control y dos nodos trabajadores. Se está ejecutando con el containerd como el Container Runtime para tu Cluster de Kubernetes, y el plugin de red Flannel para la conexión en red de los Pods en tu cluster. Has configurado completamente el Clúster Kubernetes, puedes empezar a desplegar tus aplicaciones en el Clúster Kubernetes o intentar instalar el Tablero Kubernetes para conocer mejor tu entorno Kubernetes.