Kubernetes y Rancher Desktop

¿Qué son?

Kubernetes (K8s) es un orquestador de contenedores open-source que automatiza el despliegue, escalado y gestión de aplicaciones containerizadas en clusters de máquinas .

Rancher Desktop es una aplicación de escritorio que empaqueta Kubernetes (k3s) y herramientas esenciales para el desarrollo local, disponible para Windows, macOS y Linux .

Ventajas de Kubernetes en el Desarrollo

🚀 Más Allá de Docker Compose

Mientras Docker Compose es excelente para un solo host, Kubernetes brilla cuando:

• Necesitas alta disponibilidad (0 downtime)
• Requieres escalado automático por carga
• Gestionas múltiples máquinas/nodos
• Buscas auto-recuperación ante fallos

⚙️ Modelo Declarativo

En lugar de ejecutar comandos, defines el "estado deseado" y Kubernetes se encarga de alcanzarlo y mantenerlo :

# Deseas 3 réplicas de tu app siempre ejecutándose
replicas: 3

🔄 Actualizaciones sin Downtime

• Rolling Updates: Reemplaza pods gradualmente
• Rollbacks: Revierte a versiones anteriores con un comando
• Auto-reparación: Reinicia contenedores que fallan

📊 Escalado Elástico

• Escala horizontalmente según CPU/memoria
• Distribuye carga entre pods automáticamente
• Recuperación automática ante nodos caídos

Componentes Clave de Kubernetes

Arquitectura del Cluster

Objetos Fundamentales

El Pod: Unidad Atómica

# pod.yaml - Definición básica de un Pod
apiVersion: v1
kind: Pod
metadata:
  name: mi-app-pod
  labels:
    app: mi-app
spec:
  containers:
  - name: mi-app
    image: nginx:1.25
    ports:
    - containerPort: 80

Comandos Principales de kubectl

Gestión de Recursos

# Obtener información del cluster
kubectl cluster-info
kubectl get nodes
kubectl get namespaces

# Ver recursos
kubectl get pods
kubectl get pods -n mi-namespace
kubectl get pods -o wide
kubectl get all

# Describir recursos (detalles)
kubectl describe pod <nombre-pod>
kubectl describe deployment <nombre>

# Crear recursos desde YAML
kubectl apply -f archivo.yaml
kubectl apply -f ./directorio/

# Eliminar recursos
kubectl delete -f archivo.yaml
kubectl delete pod <nombre>
kubectl delete deployment <nombre>

# Editar recursos en vivo
kubectl edit deployment <nombre>

Debugging y Logs

# Ver logs de un pod
kubectl logs <nombre-pod>
kubectl logs <nombre-pod> -c <contenedor>  # multi-contenedor
kubectl logs -f <nombre-pod>  # seguir en tiempo real

# Ejecutar comandos dentro del pod
kubectl exec -it <nombre-pod> -- /bin/bash
kubectl exec <nombre-pod> -- ls /app

# Reenviar puertos para acceso local
kubectl port-forward pod/<nombre> 8080:80

# Ver eventos del cluster
kubectl get events --sort-by='.lastTimestamp'

Escalado y Actualizaciones

# Escalar un deployment
kubectl scale deployment <nombre> --replicas=5

# Actualizar imagen de un deployment
kubectl set image deployment/<nombre> <container>=nueva-imagen:tag

# Ver estado del rollout
kubectl rollout status deployment/<nombre>

# Ver historial de actualizaciones
kubectl rollout history deployment/<nombre>

# Revertir a versión anterior
kubectl rollout undo deployment/<nombre>

# Pausar/reanudar rollout
kubectl rollout pause deployment/<nombre>
kubectl rollout resume deployment/<nombre>

Labels y Selectores

# Filtrar por labels
kubectl get pods -l app=mi-app
kubectl get pods -l "env=prod,app=web"

# Agregar/eliminar labels
kubectl label pod <nombre> version=v1
kubectl label pod <nombre> version-  # eliminar

Rancher Desktop

¿Por qué Rancher Desktop?

Diferencia con Docker Desktop

Instalación Rápida

Windows (WSL2)

# 1. Descargar installer desde GitHub
# 2. Ejecutar Rancher.Desktop.Setup.exe
# 3. Asegurar WSL2 habilitado

macOS

# Usar Homebrew
brew install --cask rancher

# O descargar .dmg desde GitHub

Linux (Debian/Ubuntu)

# Agregar repositorio APT
curl -s https://download.opensuse.org/repositories/isv:/Rancher:/stable/deb/Release.key | gpg --dearmor | sudo dd status=none of=/usr/share/keyrings/isv-rancher-stable-archive-keyring.gpg

echo 'deb [signed-by=/usr/share/keyrings/isv-rancher-stable-archive-keyring.gpg] https://download.opensuse.org/repositories/isv:/Rancher:/stable/deb/ ./' | sudo dd status=none of=/etc/apt/sources.list.d/isv-rancher-stable.list

sudo apt update
sudo apt install rancher-desktop

Linux (AppImage - todas las distros)

wget https://github.com/rancher-sandbox/rancher-desktop/releases/latest/download/rancher-desktop-latest-x86_64.AppImage
chmod +x rancher-desktop-latest-x86_64.AppImage
./rancher-desktop-latest-x86_64.AppImage

Configuración Inicial

1. Primer inicio: Selecciona versión de Kubernetes (recomendado: stable)
2. Elige runtime: containerd o dockerd (moby)
3. Recursos: Ajusta CPU/RAM para la VM
4. Acceso CLI: Los comandos kubectl, nerdctl, helm se añaden automáticamente al PATH

Comandos Útiles con Rancher Desktop

# Verificar que el cluster está funcionando
kubectl cluster-info
kubectl get nodes

# nerdctl: alternativa a docker con containerd
nerdctl images
nerdctl pull nginx:alpine
nerdctl run -d -p 80:80 nginx:alpine
nerdctl ps

# Acceder al dashboard de Rancher (en la GUI)
# O mediante port-forward si está desplegado
kubectl port-forward -n cattle-system svc/rancher 8443:443

Ejemplo Práctico: App + Base de Datos

Estructura del proyecto

mi-app-k8s/
├── deployment.yaml
├── service.yaml
├── configmap.yaml
└── namespace.yaml

Namespace (namespace.yaml)

apiVersion: v1
kind: Namespace
metadata:
  name: mi-app

ConfigMap (configmap.yaml)

apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
  namespace: mi-app
data:
  DB_HOST: "postgres-service"
  DB_NAME: "myapp"
  NODE_ENV: "development"

Deployment (deployment.yaml)

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
  namespace: mi-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web-app
  template:
    metadata:
      labels:
        app: web-app
    spec:
      containers:
      - name: app
        image: nginx:1.25
        ports:
        - containerPort: 80
        envFrom:
        - configMapRef:
            name: app-config
        resources:
          requests:
            memory: "128Mi"
            cpu: "100m"
          limits:
            memory: "256Mi"
            cpu: "200m"
        readinessProbe:
          httpGet:
            path: /health
            port: 80
          initialDelaySeconds: 5
        livenessProbe:
          httpGet:
            path: /
            port: 80
          initialDelaySeconds: 15
---
apiVersion: v1
kind: Service
metadata:
  name: web-service
  namespace: mi-app
spec:
  selector:
    app: web-app
  ports:
  - port: 80
    targetPort: 80
  type: ClusterIP

Desplegar en Rancher Desktop

# Crear namespace
kubectl apply -f namespace.yaml

# Aplicar configmap
kubectl apply -f configmap.yaml

# Desplegar aplicación
kubectl apply -f deployment.yaml

# Verificar estado
kubectl get all -n mi-app
kubectl get pods -n mi-app -w

# Acceder a la app (port-forward)
kubectl port-forward -n mi-app service/web-service 8080:80

# Escalar a 5 réplicas
kubectl scale deployment web-app -n mi-app --replicas=5

Mejores Prácticas

1. Usar namespaces para aislar entornos (dev/staging/prod)
2. Definir resource limits - Evita que un pod consuma todo el nodo
3. Health checks - Implementa readiness y liveness probes
4. Labels consistentes - Facilita selección y organización
5. Preferir Deployments sobre pods individuales
6. Usar ConfigMaps/Secrets para configuración
7. Declarativo > Imperativo - Prefiere apply -f sobre comandos directos
8. Mantener pods stateless - Usa volúmenes externos para datos

Recursos Útiles

• Documentación oficial de Kubernetes
• Rancher Desktop GitHub
• kubectl Cheat Sheet
• Kubernetes Playground