Hoy en día cada vez está más extendido el uso de contenedores, y orquestación de los mismos con soluciones como Openshift o Kubernetes. Si en nuestro día a día es algo que con lo que tenemos que lidiar continuamente, o simplemente queremos trastear con algun proyecto personal, puede ser interesante tener un pequeño laboratorio en casa para testing.

Con nuestra querida RaspberryPi podemos montarnos un pequeño cluster (de momento lo vamos a dejar como standalone) que aunque no nos vaya a servir como entorno de producción, y no sea algo rápido, ni fácil, puede resultar tremendamente entretenido.

Para comenzar lo que vamos a necesitar va a ser muy sencillo:

• RaspberryPi 4 con al menos 4GB de RAM
• Tarjeta microSD de 64GB
• Adaptador de corriente de mínimo 3A para alimentar la Raspberry
• Otro equipo con el que conectaremos por ssh.

Preparación

Lo primero será preparar el S.O. de nuestra RaspberryPi. En esta ocasión vamos a utilizar Ubuntu Server.

Para ello vamos a descargar la ISO correspondiente de su web oficial y la cargamos en nuestra SD mediante Balena Etcher.

Enchufamos el adaptador de corriente y arrancamos nuestra placa. El proceso de arranque inicial suele llevar unos 5 minutos antes de que nos permita hacer login.

Accedemos a nuestra Raspberry mediante ssh, si no tenemos monitor y teclado. El login por defecto es:

• user: ubuntu
• pass: ubuntu

1

ssh ubuntu@192.168.200.204

Una vez dentro, lo primero que nos va a pedir es establecer una contraseña.

Actualizamos paqueteria

1
2
3

sudo apt update
sudo apt upgrade -y
sudo apt autoremove -y

Preparamos el S.O. para utilizar los cgroups. Para ello añadimos al final de la linea de arranque del fichero /boot/firmware/cmdline.txt, lo siguiente:

1

cgroup_enable=cpuset cgroup_enable=memory cgroup_memory=1

Inicialmente conectamos la Raspberry por cable de red, pero podemos opcionalmente dejar configurado el Wifi como “failover”

1

sudo nano /etc/netplan/50-cloud-init.yaml

1
2
3
4
5
6
7

    wifis:
        wlan0:
            dhcp4: true
            optional: true
            access-points:
                "SSID_name":
                    password: "WiFi_password"

Corregimos nuestra zona horaria

1

sudo timedatectl set-timezone Europe/Madrid

Añadimos un nombre de host

1

sudo nano /etc/hostname

y finalmente reiniciamos

1

reboot

MicroK8s

A la hora de montar nuestro pequeño cluster de kubernetes, tenemos varias opciones:

• La vía oficial de kubernetes
• minikube
• Kubernetes embebido de Docker desktop
• microk8s

En nuestro caso, ya que estamos utilizando como base un sistema operativo, vamos a ir con la solucion de microk8s, ya que es desarrollada por la propia Canonical como paquete snap. Esto nos puede proporcionar más compatibilidad y simplicidad a la hora de mantenerlo al día.

Para ello, es tan simple como instalar el paquete.

1

sudo snap install microk8s --classic

La sintaxis para gestionar nuestro cluster con microk8s es: microk8s kubectl ******. Nuestra intencion es abstraernos lo máximo posible de esta sintaxis, y simplificarlo utilizando kubectl como un alias:

En este caso es bash pero si utilizaramos zsh habria que cambiar la ruta del fichero de aliases

1
2
3

echo 'export PATH=/snap/bin:$PATH' >> ~/.bashrc
echo "alias  kubectl='microk8s kubectl'" >> ~/.bash_aliases
source ~/.bashrc

añadimos permisos a nuestro usuario

1
2
3

    sudo usermod -a -G microk8s ubuntu
    sudo chown -f -R ubuntu ~/.kube
	newgrp microk8s

Chekeamos que está running:

1

microk8s status --wait-ready

Añadimos algunos plugins esenciales, como el de Dashboard, Ingress Registry y DNS

1
2

microk8s status --wait-ready
microk8s enable dns ingress dashboard registry

Una pequeña descripción de cada uno de ellos

1
2
3
4
5

microk8s enable ingress       # expone rutas HTTP and HTTPS desde fuera del cluster, hacia dentro del mismo.
microk8s enable dashboard     # GUI grafica para la gestión del cluster mediante interfaz web
microk8s enable dns           # crea registros DNS para los servicios y pods
microk8s enable storage       # permite gestionar el storage que proporcionamos a los pods del cluster
microk8s enable registry      # nos permite tener un registry local para almacenar las imágenes docker  

Verificamos que nuestros alias funcionan correctamente, y tenemos un nodo corriendo

1

kubectl get nodes

MetalLB

Vamos a instalar el Load Balancer, utilizando la solucion de MetalLB

1

microk8s enable metallb

Nos pedira un rango de IPS reservadas para gestionar. En mi Red casera voy a reservar estas: 192.168.200.220-192.168.200.249

Vamos a lanzar un pequeño deployment para verificar que nuestro balanceador está funcionando correctamente:

1
2
3

kubectl create deployment whoami --image=containous/whoami

kubectl expose deployment whoami --type=LoadBalancer --port=80

Podemos verificar que se ha asignado una de las IP reservadas:

1
2
3

ubuntu@RPI4:~$ kubectl get service whoami
NAME     TYPE           CLUSTER-IP       EXTERNAL-IP       PORT(S)        AGE
whoami   LoadBalancer   10.152.183.181   192.168.200.220   80:30341/TCP   4m55s

Ahora solo nos hace falta atacar la IP desde el navegador o con un simple curl

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

ubuntu@RPI4:~$ curl 192.168.200.220
Hostname: whoami-5d56c87b99-fxjvn
IP: 127.0.0.1
IP: ::1
IP: 10.1.117.20
IP: fe80::30ba:88ff:febb:a570
RemoteAddr: 10.0.1.1:51427
GET / HTTP/1.1
Host: 192.168.200.220
User-Agent: curl/7.81.0
Accept: */*

ubuntu@RPI4:~$

Dashboard

Para acceder a nuestro dashboard, necesitamos conocer la IP y puerto asignados al mismo:

1
2
3

ubuntu@RPI4:~$ kubectl -n kube-system get services | grep kubernetes-dashboard
kubernetes-dashboard        NodePort    10.152.183.148   <none>        443:30353/TCP            15m
ubuntu@RPI4:~$

Con esto ya podemos acceder al dashboard desde fuera de nuestra raspbery PI

https://{server ip}:{port number}

En mi caso:

1

https://192.168.200.204:30353

Al acceder desde el navegador, nos pedirá autenticación. Necesitamos averiguar el token. Esta información la podemos obtener en la propia configuracion de microk8s

1
2

microk8s config | grep token
    token: NW4vWGJZUEkyMDdPWVZGRnVEVXlBVjhmWHNkaUpoQ1RBN29jVGMyek44Zz0K

Copiamos el token y lo pegamos en la UI.

Con esto ya tendríamos nuestro cluster con un único nodo corriendo y listo para trabajar con él. Más adelante veremos como añadir más nodos a este cluster, eliminarlos, etc.