Manual de Aprendizaje de microk8s
Guía Práctica con Aplicación Flask de Ejemplo
Este manual te enseñará los conceptos fundamentales de microk8s utilizando una aplicación Flask real como ejemplo.
Tabla de Contenidos
[Introducción a microk8s](#introducción-a-microk8s)
[Conceptos Básicos de Kubernetes](#conceptos-básicos-de-kubernetes)
[Preparación del Entorno](#preparación-del-entorno)
[Paso 1: Crear una Imagen Docker](#paso-1-crear-una-imagen-docker)
[Paso 2: Entender los Manifiestos de Kubernetes](#paso-2-entender-los-manifiestos-de-kubernetes)
[Paso 3: Desplegar la Aplicación](#paso-3-desplegar-la-aplicación)
[Paso 4: Exponer la Aplicación](#paso-4-exponer-la-aplicación)
[Paso 5: Persistencia de Datos](#paso-5-persistencia-de-datos)
[Paso 6: Actualizar la Aplicación](#paso-6-actualizar-la-aplicación)
[Comandos Útiles](#comandos-útiles)
[Ejercicios Prácticos](#ejercicios-prácticos)
[Solución de Problemas Comunes](#solución-de-problemas-comunes)
Introducción a microk8s
¿Qué es microk8s?
microk8s es una distribución ligera de Kubernetes desarrollada por Canonical. Es ideal para: - Desarrollo local - Aprendizaje de Kubernetes - Despliegues en IoT y edge devices - Prototipado rápido
Diferencias con Kubernetes completo
| Característica | Kubernetes Completo | microk8s |
|---|---|---|
| Instalación | Compleja | Simple (un comando) |
| Recursos | Requiere más | Ligero |
| Uso | Producción grande | Desarrollo/pequeño |
| Addons | Manual | Preconfigurados |
Ventajas de microk8s
✅ Instalación en un solo comando
✅ Incluye addons preconfigurados (dashboard, registry, ingress)
✅ Ligero y eficiente
✅ Ideal para aprender Kubernetes
✅ Misma API que Kubernetes completo
Conceptos Básicos de Kubernetes
1. Pod
La unidad más pequeña de Kubernetes. Un pod contiene uno o más contenedores.
Analogía: Un pod es como una "caja" que contiene tu aplicación y todo lo que necesita para funcionar.
apiVersion: v1 kind: Pod metadata: name: mi-pod spec: containers: - name: mi-app image: mi-imagen:latest
2. Deployment
Gestiona los pods y asegura que siempre estén corriendo la cantidad deseada de réplicas.
Analogía: El deployment es como un "gerente" que asegura que siempre haya suficientes "cajas" (pods) corriendo.
apiVersion: apps/v1 kind: Deployment metadata: name: mi-deployment spec: replicas: 3 # 3 pods corriendo selector: matchLabels: app: mi-app template: metadata: labels: app: mi-app spec: containers: - name: mi-app image: mi-imagen:latest
3. Service
Proporciona una red estable para acceder a los pods. Los pods pueden cambiar, pero el service mantiene la misma dirección.
Analogía: El service es como un "receptionista" que siempre sabe dónde están los pods y te redirige al correcto.
apiVersion: v1 kind: Service metadata: name: mi-service spec: selector: app: mi-app ports: - port: 80 targetPort: 5000
4. PersistentVolumeClaim (PVC)
Solicita almacenamiento persistente para los pods. Los datos no se pierden cuando el pod se reinicia.
Analogía: El PVC es como pedir un "disco duro" que se mantiene aunque el "computador" (pod) se reinicie.
apiVersion: v1 kind: PersistentVolumeClaim metadata: name: mi-pvc spec: accessModes: - ReadWriteOnce resources: requests: storage: 5Gi
5. ConfigMap y Secret
Almacenan configuración y datos sensibles separados del código de la aplicación.
Analogía: Son como "archivos de configuración" que puedes cambiar sin modificar la aplicación.
Preparación del Entorno
Instalar microk8s
En Linux
sudo snap install microk8s --classic
Verificar instalación
microk8s status --wait-ready
Habilitar addons necesarios
microk8s enable dashboard microk8s enable registry microk8s enable ingress microk8s enable storage
Configurar kubectl
Opción 1: Usar microk8s kubectl directamente
microk8s kubectl get nodes
Opción 2: Configurar kubectl permanentemente
microk8s config > ~/.kube/config kubectl get nodes
Paso 1: Crear una Imagen Docker
¿Qué es Docker?
Docker es una tecnología que permite empaquetar aplicaciones con todas sus dependencias en contenedores.
Crear Dockerfile
El Dockerfile es como una "receta" para construir tu imagen Docker.
FROM: La imagen base (Python 3.12)
FROM python:3.12-slim
WORKDIR: Directorio de trabajo
WORKDIR /app
COPY: Copiar archivos
COPY requirements.txt .
RUN: Ejecutar comandos (instalar dependencias)
RUN pip install --no-cache-dir -r requirements.txt
COPY: Copiar el resto de archivos
COPY . .
RUN: Crear directorios necesarios
RUN mkdir -p uploads instance
EXPOSE: Puerto que la app usa
EXPOSE 5000
CMD: Comando para iniciar la app
CMD ["python", "app.py"]
Construir la imagen
cd /root/meeting_recording docker build -t localhost:32000/meeting-recording:latest .
Subir al registry de microk8s
docker push localhost:32000/meeting-recording:latest
🎯 Objetivo del paso: Empaquetar tu aplicación en un formato que Kubernetes pueda entender y ejecutar.
Paso 2: Entender los Manifiestos de Kubernetes
¿Qué son los manifiestos?
Los manifiestos son archivos YAML que describen el estado deseado de tu aplicación en Kubernetes.
Deployment Manifest
apiVersion: apps/v1 # Versión de la API kind: Deployment # Tipo de recurso metadata: name: meeting-recording # Nombre del deployment labels: app: meeting-recording # Etiquetas para identificación spec: replicas: 1 # Número de pods a mantener selector: # Cómo seleccionar los pods matchLabels: app: meeting-recording template: # Plantilla para crear pods metadata: labels: app: meeting-recording spec: containers: - name: meeting-recording image: localhost:32000/meeting-recording:latest imagePullPolicy: IfNotPresent ports: - containerPort: 5000 env: # Variables de entorno - name: DATABASEPATH value: /data/instance/app.db - name: UPLOADSPATH value: /data/uploads volumeMounts: # Montar volúmenes - name: data mountPath: /data volumes: # Definir volúmenes - name: data persistentVolumeClaim: claimName: meeting-recording-pvc
Service Manifest
apiVersion: v1 kind: Service metadata: name: meeting-recording spec: selector: app: meeting-recording # Conecta a pods con esta etiqueta ports: - port: 80 # Puerto del service targetPort: 5000 # Puerto del contenedor protocol: TCP type: NodePort # Tipo de servicio
PVC Manifest
apiVersion: v1 kind: PersistentVolumeClaim metadata: name: meeting-recording-pvc spec: accessModes: - ReadWriteOnce # Un pod puede leer/escribir resources: requests: storage: 5Gi # 5 Gigabytes de almacenamiento storageClassName: microk8s-hostpath # Tipo de almacenamiento
🎯 Objetivo del paso: Definir cómo Kubernetes debe ejecutar tu aplicación.
Paso 3: Desplegar la Aplicación
Aplicar los manifiestos
Aplicar cada manifiesto en orden
microk8s kubectl apply -f k8s-secret.yaml microk8s kubectl apply -f k8s-pvc.yaml microk8s kubectl apply -f k8s-deployment.yaml microk8s kubectl apply -f k8s-service.yaml
Verificar el despliegue
Ver pods
microk8s kubectl get pods
Ver deployment
microk8s kubectl get deployment meeting-recording
Ver servicios
microk8s kubectl get svc
Ver logs de la aplicación
Ver logs del pod
microk8s kubectl logs
Ver logs en tiempo real
microk8s kubectl logs -f
Ver logs del deployment
microk8s kubectl logs -f deployment/meeting-recording
🎯 Objetivo del paso: Poner tu aplicación a correr en Kubernetes.
Paso 4: Exponer la Aplicación
Tipos de Services
| Tipo | Descripción | Uso |
|---|---|---|
| ClusterIP | Solo accesible dentro del cluster | Comunicación interna |
| NodePort | Accesible desde fuera del cluster | Desarrollo/Testing |
| LoadBalancer | Balanceador de carga externo | Producción |
Configurar NodePort
spec: type: NodePort # Cambiar de ClusterIP a NodePort
Aplicar cambios
microk8s kubectl apply -f k8s-service.yaml
Encontrar el puerto asignado
microk8s kubectl get svc meeting-recording
Output:
NAME TYPE PORT(S) meeting-recording NodePort 80:30530/TCP
Acceder desde fuera
Obtener IP del nodo
microk8s kubectl get nodes -o wide
Acceder a la app
curl http://
🎯 Objetivo del paso: Hacer tu aplicación accesible desde fuera del cluster.
Paso 5: Persistencia de Datos
¿Por qué necesitamos persistencia?
Los pods son efímeros. Si un pod se reinicia, se pierden los datos en su filesystem. Los PVCs solucionan esto.
PVC en nuestra aplicación
volumeMounts: - name: data mountPath: /data # Monta el PVC en /data dentro del pod
Variables de entorno configuradas
env: - name: DATABASEPATH value: /data/instance/app.db # DB en volumen persistente - name: UPLOADSPATH value: /data/uploads # Uploads en volumen persistente
Verificar PVC
microk8s kubectl get pvc microk8s kubectl describe pvc meeting-recording-pvc
Probar persistencia
Crear un usuario en la aplicación
Reiniciar el pod: microk8s kubectl delete pod <nombre>
Verificar que el usuario aún existe
🎯 Objetivo del paso: Asegurar que los datos no se pierdan al reiniciar pods.
Paso 6: Actualizar la Aplicación
Flujo de actualización
Modificar el código
Reconstruir la imagen Docker
Subir al registry
Actualizar el deployment
Paso a paso
1. Modificar código
vim app.py
2. Reconstruir imagen
cd /root/meeting_recording docker build -t localhost:32000/meeting-recording:latest .
3. Subir al registry
docker push localhost:32000/meeting-recording:latest
4. Actualizar deployment (rolling update)
microk8s kubectl rollout restart deployment/meeting-recording
5. Verificar actualización
microk8s kubectl rollout status deployment/meeting-recording microk8s kubectl get pods
Rolling Update
Kubernetes actualiza los pods gradualmente, asegurando que siempre haya pods disponibles durante la actualización.
🎯 Objetivo del paso: Aprender a actualizar aplicaciones sin downtime.
Paso 7: Auto-Scaling (Escalado Automático)
¿Qué es el Horizontal Pod Autoscaler (HPA)?
El HPA es una característica de Kubernetes que ajusta automáticamente el número de réplicas de un deployment basándose en el uso de CPU, memoria u otras métricas personalizadas.
Analogía: El HPA es como un "gerente de tráfico" que abre más carriles cuando hay mucho tráfico y los cierra cuando el tráfico disminuye, pero siempre mantiene al menos un carril abierto.
¿Cómo funciona?
**Monitoreo:** HPA monitorea las métricas de los pods (CPU, memoria)
**Comparación:** Compara las métricas con los umbrales configurados
**Escalado:** Si el uso supera el umbral, aumenta las réplicas
**Reducción:** Si el uso está por debajo del umbral, reduce las réplicas
**Mínimo garantizado:** Siempre mantiene al menos el número mínimo de réplicas configurado
Requisitos previos
Verificar que metrics-server esté habilitado
microk8s status
Si no está habilitado, habilitarlo
microk8s enable metrics-server
Verificar que metrics-server esté corriendo
microk8s kubectl get pods -n kube-system | grep metrics
Configurar recursos en el Deployment
Primero, el deployment debe tener configurados los recursos requests y limits:
spec: template: spec: containers: - name: meeting-recording image: localhost:32000/meeting-recording:latest resources: requests: cpu: "100m" # Mínimo de CPU garantizado memory: "128Mi" # Mínimo de memoria garantizado limits: cpu: "500m" # Máximo de CPU permitido memory: "512Mi" # Máximo de memoria permitido
Crear el HPA
Crear HPA con:
- Mínimo: 1 réplica
- Máximo: 5 réplicas
- Escalar cuando CPU > 50%
microk8s kubectl autoscale deployment meeting-recording \ --min=1 \ --max=5 \ --cpu-percent=50
Crear HPA usando manifiesto YAML
Crear archivo k8s-hpa.yaml:
apiVersion: autoscaling/v2 kind: HorizontalPodAutoscaler metadata: name: meeting-recording-hpa spec: scaleTargetRef: apiVersion: apps/v1 kind: Deployment name: meeting-recording minReplicas: 1 # Mínimo de réplicas (siempre al menos 1) maxReplicas: 5 # Máximo de réplicas metrics: - type: Resource resource: name: cpu target: type: Utilization averageUtilization: 50 # Escalar cuando CPU > 50%
Aplicar el HPA:
microk8s kubectl apply -f k8s-hpa.yaml
Verificar el HPA
Ver el estado del HPA
microk8s kubectl get hpa
Ver detalles del HPA
microk8s kubectl describe hpa meeting-recording-hpa
Ver eventos de escalado
microk8s kubectl get events --field-selector involvedObject.kind=HorizontalPodAutoscaler
Probar el auto-scaling
1. Ver estado inicial: bash microk8s kubectl get hpa microk8s kubectl get pods
2. Simular carga:
# Instalar herramienta de carga (si no está instalada)
sudo apt install -y apache2-utils
# Generar carga en la aplicación
ab -n 1000 -c 10 http://192.168.86.177:30530/
3. Observar el escalado:
# Ver cómo aumenta el número de réplicas
watch microk8s kubectl get pods
# Ver el HPA respondiendo
watch microk8s kubectl get hpa
4. Esperar a que la carga disminuya: bash
Después de unos minutos, verás que las réplicas disminuyen
pero nunca menos de 1 (configuración minReplicas)
microk8s kubectl get pods microk8s kubectl get hpa
Configuración avanzada con múltiples métricas
apiVersion: autoscaling/v2 kind: HorizontalPodAutoscaler metadata: name: meeting-recording-hpa spec: scaleTargetRef: apiVersion: apps/v1 kind: Deployment name: meeting-recording minReplicas: 1 maxReplicas: 10 metrics: - type: Resource resource: name: cpu target: type: Utilization averageUtilization: 50 - type: Resource resource: name: memory target: type: Utilization averageUtilization: 70
Comportamiento del HPA
| Situación | Acción del HPA |
|---|---|
| CPU > 50% | Aumenta réplicas (hasta maxReplicas) |
| CPU < 50% | Reduce réplicas (hasta minReplicas) |
| Carga alta sostenida | Mantiene réplicas altas |
| Carga baja | Reduce a minReplicas (nunca menos de 1) |
Parámetros importantes
**minReplicas:** Mínimo de pods siempre activos (en nuestro caso: 1)
**maxReplicas:** Máximo de pods permitidos (en nuestro caso: 5)
**targetCPUUtilizationPercentage:** Umbral de CPU para escalar (50%)
**stabilizationWindowSeconds:** Tiempo de espera antes de reducir réplicas (evita fluctuaciones)
Eliminar el HPA
Eliminar HPA creado con comando
microk8s kubectl delete hpa meeting-recording
O eliminar HPA creado con YAML
microk8s kubectl delete -f k8s-hpa.yaml
Ventajas del auto-scaling
✅ Ahorro de recursos: Solo usa los recursos necesarios ✅ Mejor rendimiento: Escala automáticamente bajo carga ✅ Costo optimizado: En clouds, paga solo por lo que usas ✅ Resiliencia: Más pods = más capacidad de manejar fallos ✅ Automático: No requiere intervención manual
Limitaciones a considerar
⚠️ Cold starts: Los nuevos pods tardan en estar listos ⚠️ Estado compartido: Si la app no es stateless, puede haber problemas ⚠️ Base de datos: La DB también debe escalar o ser externa ⚠️ Métricas: Requiere metrics-server funcionando correctamente
🎯 Objetivo del paso: Aprender a configurar escalado automático para manejar cargas variables eficientemente.
Comandos Útiles
Gestión de Pods
Listar pods
microk8s kubectl get pods
Ver detalles de un pod
microk8s kubectl describe pod
Ver logs
microk8s kubectl logs
Ejecutar comando en un pod
microk8s kubectl exec -it
Eliminar pod
microk8s kubectl delete pod
Gestión de Deployments
Listar deployments
microk8s kubectl get deployments
Escalar deployment
microk8s kubectl scale deployment/meeting-recording --replicas=3
Ver historial de cambios
microk8s kubectl rollout history deployment/meeting-recording
Revertir a versión anterior
microk8s kubectl rollout undo deployment/meeting-recording
Gestión de Services
Listar servicios
microk8s kubectl get svc
Ver detalles de un servicio
microk8s kubectl describe svc meeting-recording
Gestión de PVCs
Listar PVCs
microk8s kubectl get pvc
Ver detalles de un PVC
microk8s kubectl describe pvc meeting-recording-pvc
Debugging
Ver eventos del cluster
microk8s kubectl get events
Ver logs de todos los pods
microk8s kubectl logs -l app=meeting-recording
Entrar en un pod para debugging
microk8s kubectl exec -it
Ejercicios Prácticos
Ejercicio 1: Escalar la Aplicación
Objetivo: Aprender a escalar aplicaciones horizontalmente.
Escalar a 3 réplicas
microk8s kubectl scale deployment/meeting-recording --replicas=3
Verificar que hay 3 pods
microk8s kubectl get pods
Volver a 1 réplica
microk8s kubectl scale deployment/meeting-recording --replicas=1
Ejercicio 2: Inspeccionar Pods
Objetivo: Aprender a investigar el estado de los pods.
Ver detalles completos de un pod
microk8s kubectl describe pod
Ver eventos del pod
microk8s kubectl get events --field-selector involvedObject.name=
Ejercicio 3: Probar Persistencia
Objetivo: Verificar que los datos persisten.
1. Crear un usuario vía API o interfaz
2. Eliminar el pod
microk8s kubectl delete pod
3. Verificar que el usuario aún existe
Ejercicio 4: Actualizar la Aplicación
Objetito: Practicar el flujo de actualización.
1. Hacer un cambio simple en app.py
2. Reconstruir y subir imagen
3. Actualizar deployment
4. Verificar que el cambio se aplicó
Ejercicio 5: Usar el Dashboard
Objetivo: Familiarizarse con la interfaz gráfica.
Acceder al dashboard
https://192.168.86.177:32748
Navegar por:
- Pods
- Deployments
- Services
- PVCs
Solución de Problemas Comunes
Problema: Pod no arranca (CrashLoopBackOff)
Síntomas: bash microk8s kubectl get pods
NAME READY STATUS RESTARTS AGE
meeting-rec... 0/1 CrashLoopBackOff 5 2m
Solución:
# Ver logs para identificar el error
microk8s kubectl logs <nombre>
# Ver eventos
microk8s kubectl describe pod <nombre>
Problema: ImagePullBackOff
Síntomas: El pod no puede descargar la imagen.
Solución:
# Verificar que la imagen existe
docker images | grep meeting-recording
# Verificar que está en el registry
curl http://localhost:32000/v2/_catalog
# Verificar imagePullPolicy en el deployment
microk8s kubectl edit deployment meeting-recording
Problema: No se puede acceder al servicio
Síntomas: No responde en el puerto NodePort.
Solución:
# Verificar que el service existe
microk8s kubectl get svc
# Verificar que los pods están corriendo
microk8s kubectl get pods
# Verificar que el selector del service coincide con los pods
microk8s kubectl describe svc meeting-recording
# Verificar firewall (si aplica)
sudo ufw status
Problema: PVC en estado Pending
Síntomas: El PVC no se puede vincular.
Solución:
# Verificar storage class
microk8s kubectl get storageclass
# Habilitar storage addon
microk8s enable storage
# Verificar que el storage class sea correcto
microk8s kubectl describe pvc meeting-recording-pvc
Recursos Adicionales
Documentación Oficial
Comandos de Referencia Rápida
Estado general
microk8s status
Dashboard
microk8s dashboard-proxy
Addons
microk8s enable
Logs
microk8s kubectl logs -f deployment/
Reiniciar deployment
microk8s kubectl rollout restart deployment/
Próximos Pasos
Una vez que domines estos conceptos básicos, puedes explorar:
**ConfigMaps y Secrets:** Gestión de configuración
**Ingress:** Routing avanzado de tráfico
**Helm:** Gestión de paquetes de Kubernetes
**Monitoring:** Prometheus y Grafana
**CI/CD:** Integración con GitOps
Conclusión
¡Felicidades! Has aprendido los fundamentos de microk8s desplegando una aplicación real. Estos conceptos son aplicables a cualquier distribución de Kubernetes, no solo microk8s.
Próximo paso: Practica con tus propias aplicaciones y explora los conceptos avanzados mencionados arriba.
Este manual fue creado usando la aplicación meeting-recording como ejemplo práctico.