Crea tu Ambiente de Desarrollo y Despliegue con Kubernetes y VSCode Tunnels

Instalación del entorno

1. Preparación del sistema

• Descarga el ISO de Ubuntu Server LTS (https://ubuntu.com/download/server)
• Instala Ubuntu server en Virtual Box o cualquier VM Manager. En el caso del taller usaré 2 VMs: un master node y un worker. (Nota: recomiendo instalar la versión minimalista para que no use muchos recursos)
• Al momento de la instalación, agrega microk8s para pruebas.

2. Configuración básica del sistema

# Actualiza los repositorios e instala herramientas básicas
sudo apt update
sudo apt install iputils-ping
sudo apt install qemu-guest-agent
sudo apt install vim

# Inicia el agente QEMU
sudo systemctl start qemu-guest-agent

# Verifica la conectividad
ping google.com

3. Configuración de microk8s

# Verifica el estado de los nodos de Kubernetes
sudo microk8s.kubectl get nodes

# Configura los permisos necesarios
sudo usermod -a -G microk8s $USER
sudo chown -f -R $USER ~/.kube
# Cierra sesión y vuelve a entrar, o ejecuta:
newgrp microk8s

4. Crear alias para kubectl

# Abre el archivo .bashrc con vim
vim ~/.bashrc

# Agrega al final del archivo la siguiente línea:
# alias kubectl='microk8s.kubectl'

# Para guardar y salir de vim:
# Presiona ESC, luego escribe :wq y presiona Enter

# Aplica los cambios inmediatamente
source ~/.bashrc

# Prueba el alias
kubectl get nodes

5. Unir nodos al cluster

# En el nodo master: crea un token de unión
microk8s add-node

# Esto mostrará una salida parecida a:
# From the node you wish to join to this cluster, run the following:
# microk8s join 10.193.246.117:25000/da161908973ee3cfa5391df5fee8dcfa/a336d9e7b90a
#
# Use the '--worker' flag to join a node as a worker not running the control plane, eg:
# microk8s join 10.193.246.117:25000/da161908973ee3cfa5391df5fee8dcfa/a336d9e7b90a --worker
#
# If the node you are adding is not reachable through the default interface you can use one of the following:
# microk8s join 10.193.246.117:25000/da161908973ee3cfa5391df5fee8dcfa/a336d9e7b90a
# microk8s join fd3a:c6b:5b60:4680:11:32ff:fe2e:4548:25000/da161908973ee3cfa5391df5fee8dcfa/a336d9e7b90a

# En el nodo worker: únete al cluster usando el comando adecuado
# Para un nodo worker, usa el comando con la opción --worker:
microk8s join 10.193.246.117:25000/da161908973ee3cfa5391df5fee8dcfa/a336d9e7b90a --worker

# NOTA: Asegúrate de que el nodo master tenga abierto el puerto 25000 (TCP).

# Verifica el estado desde el master
microk8s kubectl get nodes

6. Configuración de roles en los nodos

# Etiqueta el nodo master con el rol master
kubectl label node master node-role.kubernetes.io/master=""

# Etiqueta el nodo worker con el rol worker
kubectl label node worker node-role.kubernetes.io/worker=""

# NOTA: Sustituye master y worker por los nombres reales que te dé kubectl get nodes

# Después de etiquetar, el comando kubectl get nodes mostrará:
# NAME      STATUS   ROLES    AGE   VERSION
# master    Ready    master   15m   v1.29.1
# worker    Ready    worker   10m   v1.29.1

# Para que el master no ejecute workloads, aplica el taint:
kubectl taint nodes master node-role.kubernetes.io/master=:NoSchedule

7. Configuracion de Servidor (API) Y Cliente de kubectl

7.1. Agregar Nombre Alternativo de Sujeto (SAN) al Certificado del Servidor API

Esto es necesario si vas a acceder al API server de Kubernetes a través de un nombre de host personalizado (por ejemplo, mediante un proxy inverso).

1. Edita el archivo de configuración de CSR (Certificate Signing Request):

   sudo vim /var/snap/microk8s/current/certs/csr.conf.template
   

   Busca la sección [ alt_names ] y agrega una nueva entrada DNS para tu nombre de host. Por ejemplo, si tu nombre de host es tu-host.com, y ya tienes hasta DNS.5, añade:

   [ alt_names ]
   # ... otras entradas DNS e IP ...
   DNS.6 = tu-host.com
   

   Nota: Asegúrate de que el número (ej. DNS.6) sea consecutivo al último existente y reemplaza tu-host.com con tu nombre de host real.

2. Refresca el certificado del servidor: Este comando regenerará el certificado server.crt usando la plantilla actualizada.

   sudo microk8s refresh-certs --cert server.crt
   

3. Verifica el nuevo certificado: Comprueba que el nuevo SAN se haya incluido correctamente.

   sudo openssl x509 -in /var/snap/microk8s/current/certs/server.crt -noout -text | grep -A1 "Subject Alternative Name"
   

   Deberías ver tu nombre de host (ej. DNS:tu-host.com) en la salida.

4. Reinicia MicroK8s para aplicar los cambios:

   sudo microk8s stop
   sudo microk8s start
   

7.2. Configuración para Acceso Externo (Ej. vía Proxy Nginx y Token)

Si vas a exponer el API server a través de un proxy inverso (como Nginx en un Synology) y quieres usar autenticación basada en token:

1. Configura tu Servidor Proxy (Ej. Nginx en Synology):

   • Asegúrate de que tu proxy inverso esté configurado para dirigir el tráfico del nombre de host público (ej. tu-host.com) al servidor API de MicroK8s (ej. https://IP_DEL_MASTER_NODE:16443). Reemplaza IP_DEL_MASTER_NODE con la IP real de tu nodo master de MicroK8s.
   • Importante: Configuración de Certificados en el Proxy: Deberás configurar tu proxy Nginx para que utilice los certificados del servidor API de MicroK8s para la conexión HTTPS con el cliente. Esto implica copiar los siguientes archivos desde tu nodo master de MicroK8s a tu servidor proxy (Synology) y referenciarlos en la configuración de Nginx para el sitio correspondiente:
     • Clave Privada (Private Key): /var/snap/microk8s/current/certs/server.key
     • Certificado (Certificate): /var/snap/microk8s/current/certs/server.crt (Este ya debería incluir tu SAN personalizado).
     • Certificado Intermedio/CA (Opcional, pero recomendado para la cadena de confianza): /var/snap/microk8s/current/certs/ca.crt (El cliente kubectl también usará esta CA en su certificate-authority-data).
   • Importante: Paso de Cabecera de Autorización: El proxy debe estar configurado para pasar la cabecera Authorization del cliente al backend (MicroK8s). En Nginx, esto se logra a menudo con la directiva:

     proxy_set_header Authorization $http_authorization;
     

     Y para evitar que Nginx elimine la cabecera si está vacía (lo cual puede ocurrir si el cliente no envía una cabecera de autorización, aunque para la autenticación por token sí la enviará):

     proxy_pass_request_headers on;
     

2. Crea un ServiceAccount y un Token en MicroK8s: Este ServiceAccount se usará para la autenticación a través del proxy.

   # Crea el ServiceAccount (ej. en el namespace kube-system)
   sudo microk8s kubectl create serviceaccount proxy-user -n kube-system
   
   # Otorga permisos de administrador del clúster al ServiceAccount
   sudo microk8s kubectl create clusterrolebinding proxy-admin-binding --clusterrole=cluster-admin --serviceaccount=kube-system:proxy-user
   
   # Genera un token de larga duración para el ServiceAccount
   sudo microk8s kubectl create token proxy-user -n kube-system --duration=876000h 
   

   Copia el token generado, lo necesitarás para configurar kubectl.

7.3. Configuración del Cliente kubectl

1. Obtén la configuración base de kubectl desde MicroK8s: Ejecuta esto en el nodo master de MicroK8s.

   sudo microk8s config
   

   Esto mostrará la configuración YAML. Cópiala.

2. Modifica el archivo ~/.kube/config en tu máquina cliente: Pega la configuración copiada en tu archivo ~/.kube/config. Si el archivo ya existe, puedes añadir esto como un nuevo contexto o modificar uno existente. Es recomendable hacer una copia de seguridad de tu ~/.kube/config antes de modificarlo.

3. Ajusta la configuración para usar el token y el servidor proxy:

   • server: En la sección clusters:, para el clúster que usarás con el proxy, cambia la dirección del server para que apunte a tu nombre de host público a través del proxy (ej. https://tu-host.com:16443).
   • certificate-authority-data: Asegúrate de que el certificate-authority-data para este clúster sea el contenido en Base64 del archivo /var/snap/microk8s/current/certs/ca.crt de tu nodo MicroK8s. El comando sudo microk8s config ya debería proporcionarlo correctamente.
   • user: En la sección users:, para el usuario que vas a usar con el token:
     • Comenta o elimina las líneas client-certificate-data y client-key-data.
     • Añade una línea token: y pega el token que obtuviste en el paso anterior.

   Ejemplo de la sección de usuario modificada en ~/.kube/config:

   # ... (otras partes del kubeconfig como clusters, contexts) ...
   users:
   - name: microk8s-user # o el nombre de usuario que corresponda en la salida de 'microk8s config'
     user:
       # client-certificate-data: LS0tLS1CRUdJTiBDRVJUSUZJQ0FU... (comentado o eliminado)
       # client-key-data: LS0tLS1CRUdJTiBSU0EgUFJJVkFURSBLRVk... (comentado o eliminado)
       token: "AQUI_VA_EL_TOKEN_COPIADO_DEL_PASO_7.2.2"
   # ... (otros usuarios si los hay) ...
   

   8. Agregando volumen con NFS

   8.1 Agrega soporte en el host para NFS

   Crea la carpeta donde quieres se guarde la informacion de los volumenes del Cluster y por ultimo dales permiso a las ips de las VMs para conectarse por NFS.

   8.2 En Ambas VMs

   sudo apt update
   sudo apt install nfs-common -y
   microk8s enable dns
   

   8.3 Crea un PV y un PVC

   Usa como base ./01-pv-pvc.yaml

   8.4 Usa el PVC en algun pod o deployment

   Por ejemplo:

   apiVersion: v1
   kind: Pod
   metadata:
   name: nfs-test-pod
   spec:
   containers:
   - name: app
       image: busybox
       command: ["sleep", "3600"]
       volumeMounts:
       - mountPath: "/mnt/data"
       name: nfs-vol
   volumes:
   - name: nfs-vol
       persistentVolumeClaim:
       claimName: pvc-nfs-synology