Kubernetes y Docker: Guía Práctica para Principiantes DevOps

Contenedores y orquestación han revolucionado el desarrollo y deployment de aplicaciones modernas. Docker permite empaquetar aplicaciones con todas sus dependencias, mientras Kubernetes orquesta contenedores a escala empresarial. En 2024, dominar estas tecnologías es requisito fundamental para DevOps Engineers, con el 89% de empresas tech españolas usando contenedores en producción.

¿Por Qué Contenedores?

Antes de contenedores, desplegar aplicaciones era pesadilla: "funciona en mi máquina" era frase común. Diferencias entre entornos de desarrollo, staging y producción causaban bugs inesperados. Contenedores solucionan esto empaquetando aplicación y dependencias en unidad portable idéntica en todos los entornos.

Beneficios de Contenedores

• Consistencia: Mismo comportamiento en dev, staging, producción
• Aislamiento: Aplicaciones no interfieren entre sí
• Eficiencia: Arrancan en segundos vs minutos de VMs
• Portabilidad: Corren en cualquier infraestructura con Docker
• Escalabilidad: Fácil replicar instancias para manejar carga

Docker: Fundamentos

Conceptos Básicos

Imagen: Template inmutable con aplicación y dependencias. Como receta de pastel. Ejemplos: node:18, python:3.11-slim, nginx:latest.

Contenedor: Instancia ejecutable de imagen. Como pastel horneado desde receta. Múltiples contenedores desde misma imagen.

Dockerfile: Archivo texto con instrucciones para construir imagen. Define sistema operativo base, dependencias, código fuente, comando de inicio.

Ejemplo Práctico: Aplicación Node.js

Supongamos tienes app Express.js. Dockerfile básico:

FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 3000
CMD ["node", "server.js"]

Construir imagen: docker build -t mi-app:1.0 .

Ejecutar contenedor: docker run -p 3000:3000 mi-app:1.0

Docker Compose: Multi-Container Apps

Aplicaciones reales tienen múltiples servicios: frontend, backend, base de datos. Docker Compose gestiona todo con archivo YAML:

version: '3.8'
services:
  backend:
    build: ./backend
    ports: ["5000:5000"]
    environment:
      - DATABASE_URL=postgres://db:5432/myapp
  frontend:
    build: ./frontend
    ports: ["3000:3000"]
  db:
    image: postgres:14
    environment:
      - POSTGRES_PASSWORD=secret

Arrancar toda la aplicación: docker-compose up

Kubernetes: Orquestación a Escala

Docker es genial para desarrollo local y deployments simples. Pero producción empresarial requiere: alta disponibilidad, auto-scaling, rolling updates, self-healing, load balancing. Aquí entra Kubernetes.

Arquitectura Kubernetes

Cluster: Conjunto de máquinas (nodes) ejecutando aplicaciones containerizadas. Nodes pueden ser físicos o VMs.

Control Plane: Cerebro del cluster. Gestiona scheduling, mantiene estado deseado, responde a eventos. Componentes: API Server, Scheduler, Controller Manager, etcd (base datos distribuida).

Nodes (Workers): Máquinas ejecutando contenedores. Cada node tiene Kubelet (agente comunicando con control plane), Container Runtime (Docker/containerd), kube-proxy (networking).

Objetos Kubernetes Esenciales

Pods

Unidad mínima deployable. Grupo de uno o más contenedores con storage/network compartido. Generalmente 1 contenedor por pod. Pods son efímeros: Kubernetes los crea/destruye dinámicamente.

Deployments

Gestiona réplicas de pods. Define estado deseado: "quiero 3 réplicas de mi app corriendo". Kubernetes mantiene ese estado automáticamente. Si pod falla, crea reemplazo. Permite rolling updates sin downtime.

Services

Abstracción exponiendo pods como servicio de red. Pods tienen IPs efímeras que cambian. Services proveen IP/DNS estable. Tipos: ClusterIP (interno), NodePort (expone puerto), LoadBalancer (cloud provider).

Ejemplo Deployment Práctico

Deployment YAML para app Node.js:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mi-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: mi-app
  template:
    metadata:
      labels:
        app: mi-app
    spec:
      containers:
      - name: backend
        image: mi-app:1.0
        ports:
        - containerPort: 3000
        resources:
          limits:
            memory: "256Mi"
            cpu: "500m"

Aplicar: kubectl apply -f deployment.yaml

Workflow DevOps Completo

1. Desarrollo Local con Docker

Desarrolladores crean Dockerfile y docker-compose.yml. Prueban aplicación localmente en contenedores idénticos a producción. Commitean cambios a Git.

2. CI/CD Pipeline

GitHub Actions/GitLab CI detecta push. Ejecuta tests automáticos. Construye imagen Docker. Push a registry (Docker Hub, AWS ECR). Aplica manifests Kubernetes.

3. Deployment en Kubernetes

Kubernetes pull nueva imagen. Realiza rolling update: crea nuevos pods, espera health checks, termina pods antiguos gradualmente. Zero downtime.

4. Monitorización

Prometheus recolecta métricas (CPU, memoria, latencia). Grafana visualiza dashboards. Alertas automáticas si errores o latencia alta.

Best Practices

Docker

• Usa imágenes base oficiales y ligeras (alpine)
• Multi-stage builds para minimizar tamaño imagen
• No corras contenedores como root: especifica USER
• .dockerignore para excluir node_modules, .git
• Tagea imágenes con versiones semánticas, no latest en prod

Kubernetes

• Define resource limits/requests para CPU y memoria
• Usa health checks: liveness y readiness probes
• ConfigMaps para configuración, Secrets para credenciales
• Horizontal Pod Autoscaler para escalar según carga
• Namespaces para separar entornos (dev, staging, prod)

Errores Comunes de Principiantes

Error 1: Imagenes Gigantes

Usar FROM ubuntu y apt-get install todo. Solución: usa alpine, multi-stage builds. Imagen Node.js puede pasar de 900MB a 150MB.

Error 2: Datos en Contenedores

Guardar datos importantes dentro contenedores. Contenedores son efímeros: se pierden al borrar. Solución: Volumes de Docker o PersistentVolumes de Kubernetes.

Error 3: Sin Resource Limits

No definir límites CPU/memoria. Un pod puede consumir todos recursos del node. Solución: siempre define limits y requests.

Próximos Pasos

Practica dockerizando tus proyectos personales. Despliega cluster Kubernetes local con Minikube o K3s. Sigue tutoriales oficiales de Kubernetes. Participa en comunidades: Kubernetes Slack, Docker Community Forums.

Certificaciones valoradas: Docker Certified Associate (DCA), Certified Kubernetes Administrator (CKA), Certified Kubernetes Application Developer (CKAD). Estas credenciales incrementan empleabilidad significativamente en mercado DevOps español.

¿Quieres dominar DevOps profesionalmente? Nuestro programa DevOps Engineering cubre Docker, Kubernetes, CI/CD, Terraform, AWS en profundidad con proyectos empresariales reales. Solicita información.