MicroK8s¶

MicroK8s es una distribución ligera de Kubernetes desarrollada por Canonical (la empresa detrás de Ubuntu), diseñada para ser fácil de instalar, mantener y ejecutar en:

• Desarrolladores locales (portátiles o sobremesa)
• Sistemas edge o embebidos
• Entornos de pruebas
• Entornos de producción pequeños o medianos

Introducción¶

MicroK8s - Zero-ops Kubernetes for developers, edge and IoT

MicroK8s - MicroK8s documentation - home

Características¶

Despliegue¶

Kubernetes de alta disponibilidad, con gestión de operaciones totalmente automatizada y sin interrupciones, desde estaciones de trabajo de desarrolladores hasta producción.

Entorno¶

  -----------+-----------------------------+-----------------------------+------------
             |                             |                             |
       192.168.1.251                 192.168.1.252                192.168.1.253
  +----------+------------+    +-----------+------------+   +------------+------------+
  | [k8s1.cluster.local]  |    |  [k8s2.cluster.local]  |   |  [k8s3.cluster.local]   |
  |     Control Plane     |    |      Worker Node       |   |      Worker Node        | 
  +------------------ ----+    +------------------------+   +-------------------------+

3 x servidores ubuntu 26.04

El dominio estándar en Kubernetes es cluster.local. Funciona bien en la mayoría de los casos y es importante para la resolución de nombres entre servicios.

Adicionalmente puedes añadir al fichero de resolución local de cada host /etc/hosts las siguientes lineas:

192.168.1.251   k8s1.cluster.local   k8s1
192.168.1.252   k8s2.cluster.local   k8s2
192.168.1.253   k8s3.cluster.local   k8s3

Instalación¶

MicroK8s instalará un Kubernetes minimalista y ligero que podrás ejecutar y usar en prácticamente cualquier máquina. Se instala en un instante:

# Instala la versión mas reciente estable de  Microk8s
sudo snap install microk8s --classic --channel=latest/stable

MicroK8s crea un grupo para permitir el uso sin problemas de comandos que requieren privilegios de administrador. Para agregar su usuario actual al grupo y obtener acceso al directorio de caché .kube, ejecute los siguientes comandos:

sudo usermod -a -G microk8s $USER
mkdir -p ~/.kube
chmod 0700 ~/.kube
# Volver a ingresar a la sesión para que se aplique
su - $USER

Comandos¶

# Comprobar estado
microk8s status --wait-ready

# Ver nodos
microk8s kubectl get nodes

# Ver servicios
microk8s kubectl get services

Para usar solo el comando kubectl añadir al fichero ~/.bash_aliases la linea

echo "alias kubectl='microk8s kubectl'" >> ~/.bash_aliases && source ~/.bash_aliases

Clúster¶

Añadir nodos¶

Para crear un clúster a partir de dos o más instancias de MicroK8s en ejecución, utilice el comando microk8s add-node. La instancia de MicroK8s en la que se ejecuta este comando será un nodo master alojará el "control plane" de Kubernetes:

microk8s add-node

El comando devolverá algunas instrucciones de unión que deben ejecutarse en la instancia de MicroK8s que desea unir al clúster:

microk8s join 192.168.1.230:25000/92b2db237428470dc4fcfc4ebbd9dc81/2c0cb3284b05

Eliminar nodos¶

# En el nodo a eliminar
microk8s leave

# En el nodo master
microk8s remove-node <IP_nodo_a_eliminar>

Addons¶

MicroK8s utiliza el mínimo de componentes para un Kubernetes puro y ligero. Sin embargo, hay muchas funciones adicionales disponibles  "addons" que son componentes preconfigurados que proporcionarán capacidades adicionales.

MicroK8s - MicroK8s Addons

Puedes consultar la lista de complementos disponibles e instalados en cualquier momento ejecutando:

microk8s status

microk8s enable hostpath-storage

⚠️ IMPORTANTE: El almacenamiento Hostpath no es adecuado para entornos de producción.

Ingress¶

Este complemento añade un controlador de entrada NGINX para MicroK8. Se habilita ejecutando el comando:

microk8s enable ingress

Con Ingress habilitado, se puede crear una regla de tipo "ingress" HTTP/HTTPS. por ejemplo:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: http-ingress
spec:
  rules:
  - http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: some-service
            port:
              number: 80

Cert-Manager¶

Cert-Manager es la solución estándar para la gestión de certificados en clústeres de Kubernetes. Se habilita ejecutando el comando:

microk8s enable cert-manager

ClusterIssuer¶

Se utiliza un recurso ClusterIssuer para configurar una cuenta con Let's Encrypt. Solo necesita una dirección de correo electrónico (asegúrese de usar una válida).Global -> para todo el clúster

• Se aplica una sola vez y puedes usarlo en cualquier namespace.
• Ideal para producción cuando quieres certificados automáticos a nivel de clúster.

Manifiesto "letsencrypt-staging*.yaml*"

apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
  name: letsencrypt-staging
spec:
  acme:
    # The ACME server URL
    server: https://acme-staging-v02.api.letsencrypt.org/directory
    # Email address used for ACME registration
    email: user@example.com
    # Name of a secret used to store the ACME account private key
    privateKeySecretRef:
      name: letsencrypt-staging
    # Enable the HTTP-01 challenge provider
    solvers:
      - http01:
          ingress:
            class: public

Manifiesto "letsencrypt-prod*.yaml*":

apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
  name: letsencrypt-prod
spec:
  acme:
    # The ACME server URL
    server: https://acme-v02.api.letsencrypt.org/directory
    # Email address used for ACME registration
    email: user@example.com
    # Name of a secret used to store the ACME account private key
    privateKeySecretRef:
      name: letsencrypt-prod
    # Enable the HTTP-01 challenge provider
    solvers:
      - http01:
          ingress:
            class: public

# ClusterIssuer test
kubectl apply -f letsencrypt-staging.yaml

# ClusterIssuer Producción
kubectl apply -f letsencrypt-prod.yaml

Comprobación¶

# Lista ClusterIssuers
kubectl get clusterissuer

# Obtener detalles del ClusterIssuer
kubectl describe clusterissuer letsencrypt-staging
kubectl describe clusterissuer letsencrypt-prod

Persistent Volumes¶

Si se utiliza el almacenamiento simple proporcionado por el complemento de almacenamiento hostpath, hay que tener en cuenta que solo estará disponible para los nodos en los que se haya habilitado. Para el almacenamiento en clúster, se debe configurar un almacenamiento alternativo.

NFS¶

CSI driver para NFS¶

En la práctica debes instalar nfs-common en todos los nodos worker/control-plane donde puedan ejecutarse pods que monten PVCs NFS.

# instala nfs-common en todos los nodos del cluster
sudo apt update
sudo apt install -y nfs-common

# comprueba cambiando la IP del NFS server
which mount.nfs
showmount -e 10.0.0.42 

Habilite el complemento Helm3 (si aún no está habilitado) y agregue el repositorio para el controlador NFS CSI:

microk8s enable helm3
microk8s helm3 repo add csi-driver-nfs https://raw.githubusercontent.com/kubernetes-csi/csi-driver-nfs/master/charts
microk8s helm3 repo update

Instalar el driver de Helm en el espacio de nombres kube-system:

microk8s helm3 install csi-driver-nfs csi-driver-nfs/csi-driver-nfs \
    --namespace kube-system \
    --set kubeletDir=/var/snap/microk8s/common/var/lib/kubelet

En este punto, se pueden listar los controladores CSI disponibles en el clúster de Kubernetes.

microk8s kubectl get csidrivers

NAME             ATTACHREQUIRED   PODINFOONMOUNT   STORAGECAPACITY   TOKENREQUESTS   REQUIRESREPUBLISH   MODES        AGE
nfs.csi.k8s.io   false            false            false    

StorageClass para NFS¶

Crear una clase de almacenamiento de Kubernetes que utilice el controlador CSI nfs.csi.k8s.io. Suponiendo que haya configurado un recurso compartido NFS /volume1/k8s y que la dirección de su servidor NFS sea 10.0.0.42

# sc-nfs.yaml
---
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: nfs-csi
provisioner: nfs.csi.k8s.io
parameters:
  server: 10.0.0.42
  share: /volume1/k8s
  subDir: "${pvc.metadata.namespace}/${pvc.metadata.name}"
  onDelete: retain
reclaimPolicy: Retain
allowVolumeExpansion: true
volumeBindingMode: Immediate
mountOptions:
  - hard
  - nfsvers=4.0

# aplica el maniefiesto creado 
kubectl apply -f sc-nfs.yaml

# Comprueba
kubectl get storageclass

NAME      PROVISIONER      RECLAIMPOLICY   VOLUMEBINDINGMODE   ALLOWVOLUMEEXPANSION   AGE
nfs-csi   nfs.csi.k8s.io   Retain          Immediate           true                   17s

PersistentVolumeClaim¶

El último paso consiste en crear un nuevo PersistentVolumeClaim utilizando la clase de almacenamiento nfs-csi. Esto es tan sencillo como especificar storageClassName: nfs-csi en la definición del PVC.

# pvc-nfs.yaml
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-pvc
spec:
  storageClassName: nfs-csi
  accessModes: [ReadWriteOnce]
  resources:
    requests:
      storage: 5Gi

# aplica el maniefiesto creado 
kubectl apply -f pvc-nfs.yaml

# Comprueba
kubectl describe pvc my-pvc

Headlamp¶

Headlamp es una interfaz de usuario de Kubernetes fácil de usar centrada en la extensibilidad

# 1) Añadir repo Helm de Headlamp
microk8s helm3 repo add headlamp https://kubernetes-sigs.github.io/headlamp/
microk8s helm3 repo update

# 2) Instalar en kube-system (o crea un namespace propio si prefieres)
microk8s helm3 install headlamp headlamp/headlamp -n kube-system

Acceso rápido (sin Ingress): port-forward¶

microk8s kubectl -n kube-system get svc | grep headlamp
microk8s kubectl -n kube-system port-forward svc/headlamp 8080:80 --address 0.0.0.0

Abres http://<IP-del-nodo>:8080.

Inicio de sesión¶

Headlamp permite login con bearer token (ServiceAccount) o con certificado cliente; lo habitual es token + RBAC.

Service Account token¶

#Create a Service Account:
kubectl -n kube-system create serviceaccount headlamp-admin

# Give admin rights to the account
kubectl create clusterrolebinding headlamp-admin \
--serviceaccount=kube-system:headlamp-admin \
--clusterrole=cluster-admin

# Create the token
kubectl create token headlamp-admin -n kube-system

Argo CD¶

Argo CD es una popular herramienta declarativa de entrega continua (Continuous Delivery / CD) diseñada específicamente para Kubernetes, la cual opera bajo el enfoque GitOps. Actúa como el puente automatizado entre tu repositorio de código y tu infraestructura.

https://argoproj.github.io/cd/

¿Cómo funciona?¶

• Git como fuente de la verdad: Toda la configuración y los manifiestos de tus aplicaciones (archivos YAML, Helm charts, Kustomize) se almacenan en un repositorio Git.
• Monitoreo continuo: Argo CD se instala como un controlador dentro de tu clúster de Kubernetes y supervisa constantemente el estado actual de tus aplicaciones.
• Sincronización: Compara el estado real de los pods y servicios en tu clúster con el estado deseado definido en Git. Si detecta una diferencia, puede alertarte o sincronizar automáticamente los cambios para que tu clúster coincida exactamente con lo que está en tu repositorio.

Beneficios principales¶

• Despliegues automatizados: Olvídate de ejecutar comandos manuales como kubectl apply. Los despliegues ocurren de forma automática cuando subes cambios a Git.
• Trazabilidad y auditoría: Cada cambio realizado queda registrado en el historial de Git, sabiendo exactamente qué versión está desplegada y quién la modificó.
• Interfaz visual: Incluye un dashboard web que te permite ver el estado de tus aplicaciones y la topología de tu infraestructura en tiempo real.
• Recuperación ante desastres: Si un contenedor se elimina accidentalmente o falla, Argo CD lo detecta y lo restaura al estado deseado.

Instalación¶

kubectl create namespace argocd

kubectl apply -n argocd --server-side --force-conflicts \
  -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml

kubectl -n argocd get pods -o wide
kubectl -n argocd rollout status deploy/argocd-server

Instalar Argo CD CLI¶

VERSION=\$(curl -L -s https://raw.githubusercontent.com/argoproj/argo-cd/stable/VERSION)

curl -sSL -o argocd-linux-amd64 \
  "https://github.com/argoproj/argo-cd/releases/download/v\${VERSION}/argocd-linux-amd64"

sudo install -m 555 argocd-linux-amd64 /usr/local/bin/argocd
rm argocd-linux-amd64

argocd version --client

Nota para MicroK8s: Puede aparecer el error "invalid configuration: no configuration has been provided, try setting KUBERNETES_MASTER environment variable". Significa que el binario argocd no está encontrando la configuración de Kubernetes. Es típico en MicroK8s cuando kubectl funciona porque es un alias/wrapper de microk8s kubectl, pero no existe un ~/.kube/config estándar para otras herramientas.

Para corregirlo:

echo 'export KUBECONFIG=/var/snap/microk8s/current/credentials/client.config' >> ~/.bashrc
source ~/.bashrc

Iniciar sesión mediante la CLI¶

La contraseña inicial para la cuenta de administrador se genera automáticamente y se almacena como texto sin cifrar en el campo contraseña, en un secreto llamado argocd-initial-admin-secret en el espacio de nombres de instalación de Argo CD.

argocd admin initial-password -n argocd

Aviso de seguridad: Una vez que haya cambiado la contraseña, debe eliminar el secreto argocd-initial-admin-secret del espacio de nombres de Argo CD. Este secreto solo sirve para almacenar la contraseña generada inicialmente en texto plano y puede eliminarse sin problemas en cualquier momento.

Acceder a la UI de Argo CD¶

Mediante port-forward:

kubectl -n argocd port-forward svc/argocd-server 8080:443 --address 0.0.0.0 &

k9s¶

https://k9scli.io/

• K9s es una herramienta de línea de comandos interactiva para Kubernetes.
• Te permite navegar, monitorizar y gestionar clústeres de K8s desde la terminal.

Características¶

1. Navegación rápida

   • Pulsa : y escribe recursos (pods, deployments, svc, ingress, etc.) y navega entre ellos.
   • Usa arrow keys para moverte, enter para abrir detalles de un pod o contenedor.

   • Logs en tiempo real

   • Selecciona un pod y pulsa l para ver logs.

   • Puedes seguir logs de todos los contenedores de un pod o filtrarlos.

   • Acciones sobre pods y recursos

   • Reiniciar (r), borrar (d), escalar (s) deployments directamente desde la UI de terminal.

   • Filtrado y búsqueda

   • Ctrl+f para buscar pods por nombre, label o status.

   • Filtrar por namespace: :ns <nombre_namespace>.

   • Soporte multi-clúster

   • Detecta todos los contextos de tu kubeconfig.

   • Cambia rápidamente de un clúster a otro (:ctx <context>).

   • Temas y colores

   • Muestra pods en verde/amarillo/rojo según estado, con alertas visuales.

   • Personalizable mediante config file.

Ventajas¶

• Muy rápido, todo en terminal.
• Ideal para operaciones de emergencia sin abrir UI web.
• Compatible con cualquier clúster K8s (MicroK8s, k3s, EKS, AKS, GKE…).
• Ligero, no necesita navegador ni plugins externos.

Instalación¶

Windows¶

1️⃣ Instalar¶

Usando un terminal en modo administrador de PowerShell

# Install chocolatey
Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))

# instala via chocolatey
choco install k9s

# Ejecuta k9s
k9s

2️⃣ Exportar kubeconfig de MicroK8s¶

MicroK8s guarda su configuración dentro del nodo Linux. Necesitas copiarla a Windows.

En el nodo MicroK8s

sudo microk8s config 

Esto imprime el contenido del kubeconfig.

• Copia todo el contenido a un archivo microk8s-config.yaml en tu máquina Windows, por ejemplo:

C:\Users\<usuario>\.kube\config-microk8s.yaml

3️⃣ Conectar K9s al clúster MicroK8s¶

1. En Windows, define la variable de entorno KUBECONFIG apuntando al archivo que creaste:

setx KUBECONFIG "C:\Users\<usuario>\.kube\config-microk8s.yaml"

Nota: No olvides especificar tu usuario y cierra y abre PowerShell de nuevo para que se aplique.

1. Abre K9s:

k9s

Comandos básicos¶