Construyendo un clúster de Kubernetes en Raspberry Pi (con automatización)

Tabla de contenido

Hace unos meses, tuve la suerte de conseguir un montón de minicomputadoras Raspberry Pi de MariaDB Corporation. Mi idea era construir un clúster de Linux donde pudiera mostrar algunas de las capacidades de las bases de datos MariaDB en Docker y Kubernetes. Así que ensamblé el clúster y jugué con Ansible para configurar los dispositivos de manera automatizada, ¡no quería copiar/pegar una multitud de comandos en cada uno de los 8 dispositivos! Puedes encontrar un tutorial completo con muchas fotos e instrucciones detalladas en DZone.

En esta publicación, me centro en los comandos necesarios para configurar un clúster de Kubernetes. Supongo que ya tienes un conjunto de dispositivos Raspberry Pi funcionando y conectados a tu red local.

Habilita grupos de control
#

Los grupos de control (o cgroups) es una característica del kernel de Linux que permite asignar recursos, como CPU y memoria, a procesos. Kubernetes utiliza esta característica del kernel para limitar recursos a los procesos. Para habilitar esta característica, conéctate por SSH a tu Raspberry Pi y ejecuta:

sudo sh -c "echo ' cgroup_enable=memory cgroup_memory=1' >> /boot/cmdline.txt"

Configura el nombre de host
#

Para asegurarte de que el nombre de host esté configurado correctamente, ejecuta:

sudo sh -c "echo '$(hostname).local' > /etc/hostname"

Además, configura la configuración de localización para evitar problemas más adelante:

export LC_ALL=C.UTF-8
export LANG=C.UTF-8
echo "LC_ALL=en_US.UTF-8" | sudo tee -a /etc/environment
echo "en_US.UTF-8 UTF-8" | sudo tee -a /etc/locale.gen
echo "LANG=en_US.UTF-8" | sudo tee -a /etc/locale.conf
sudo locale-gen en_US.UTF-8

Reinicia la máquina para aplicar los cambios:

sudo reboot

Instalar Kubernetes
#

Dado que estamos usando dispositivos Raspberry Pi, tiene sentido usar una de las distribuciones ligeras de Kubernetes. En mi caso, utilicé Microk8s de Ubuntu. Otra buena opción es K3s.

Estos son los comandos requeridos (ejecútalos en cada dispositivo):

sudo apt install -y snapd
sudo snap install core
sudo snap install microk8s --classic
sudo usermod -a -G microk8s pi
sudo chown -f -R pi ~/.kube

Configura los nodos maestros y secundarios
#

Una vez que hayas instalado todo el software requerido en todos los nodos, debes elegir un nodo para ser el maestro en el clúster. En el nodo maestro, debes generar un token (de un solo uso) para cada nodo secundario que quieras unir al clúster.

Conéctate por SSH al nodo maestro:

ssh [email protected]

Genera un token:

microk8s.add-node --token-ttl 300

Copia la cadena de token y el puerto. Conéctate por SSH al primer nodo secundario y ejecuta:

microk8s.join rpi01.local:25000/TOKEN

Repite el proceso (generar token en el maestro + unirse desde el nodo secundario) para cada nodo secundario.

Verifica el estado
#

Puedes verificar el estado actual del clúster desde cualquiera de los nodos, ejecutando:

microk8s.kubectl get node

Deberías ver una lista de todos los nodos en el clúster cada uno en el estado Ready.

Elimina nodos del clúster
#

Si en algún momento quieres eliminar un nodo del clúster, conéctate por SSH a él y ejecuta:

microk8s.leave
microk8s remove-node

Automatiza con Ansible
#

Puedes automatizar la mayoría de estos pasos usando Ansible. He creado varios playbooks de Ansible para configurar un clúster de Kubernetes en Raspberry Pi sin tener que ejecutar manualmente los mismos comandos en cada dispositivo:

ping.yml: Hace ping a todas las máquinas
new-cluster.yml: Actualiza las máquinas y expande su sistema de archivos
shutdown.yml: Apaga todas las máquinas
microk8s-prepare.yml: Prepara para la instalación de Kubernetes (Microk8s)
microk8s-install.yml: Instala Kubernetes (MicroK8s)
microk8s-master.yml: Genera tokens de unión en el nodo maestro
microk8s-workers.yml: Hace que los secundarios se unan al clúster
temperature.yml: Muestra la temperatura de cada máquina

Debes crear un inventario de Ansible como el siguiente:

# Clúster de Raspberry Pi de 8 nodos
[rpies]
rpi[01:08].local ansible_user=pi

[master]
rpi01.local ansible_user=pi

[workers]
rpi02.local ansible_user=pi token=¡CAMBIA_ESTO!!!
rpi03.local ansible_user=pi token=¡CAMBIA_ESTO!!!
rpi04.local ansible_user=pi token=¡CAMBIA_ESTO!!!
rpi05.local ansible_user=pi token=¡CAMBIA_ESTO!!!
rpi06.local ansible_user=pi token=¡CAMBIA_ESTO!!!
rpi07.local ansible_user=pi token=¡CAMBIA_ESTO!!!
rpi08.local ansible_user=pi token=¡CAMBIA_ESTO!!!

[workers:vars]
master=rpi01.local:¡CAMBIA_ESTO_TAMBIÉN!!!

Luego ejecuta cualquiera de los playbooks de la siguiente manera:

ansible-playbook algun-playbook.yml

Dado que esto está pensado para ser un ambiente de laboratorio para jugar, deshabilité la verificación de la clave del host (¡usa claves SSH en entornos de producción!) y habilité el pedido de contraseña en el archivo /etc/ansible/ansible.cfg: