QUÉ ES KUBERNETES: LA GUÍA COMPLETA

Kubernetes es una plataforma de código abierto diseñada para automatizar el despliegue, el escalado y la gestión de aplicaciones en contenedores. Su nombre proviene del griego y significa “timonel” o “piloto”, lo que refleja perfectamente su función: dirigir y controlar la complejidad de ejecutar aplicaciones modernas a gran escala. Kubernetes se ha convertido en el estándar de facto de la industria para la orquestación de contenedores y es mantenido por la Cloud Native Computing Foundation (CNCF)

¿Por qué surgió Kubernetes?

Antes de los contenedores, popularizados por Docker, las aplicaciones se desplegaban en máquinas virtuales o servidores físicos. Esto generaba problemas de consistencia, desperdicio de recursos y dificultad para escalar.
Los contenedores resolvieron gran parte de estos problemas al empaquetar la aplicación junto con sus dependencias. Sin embargo, cuando se tienen cientos o miles de contenedores, gestionarlos manualmente se vuelve imposible. Ahí es donde entra Kubernetes se encarga de orquestar los contenedores de forma inteligente y automática.

¿Qué hace Kubernetes exactamente?

  • Kubernetes permite: Desplegar aplicaciones de forma declarativa, se define el estado deseado y él se encarga de alcanzarlo.
  • Escalar automáticamente según la demanda.
  • Autorreparación: si un contenedor o un nodo falla, Kubernetes lo reinicia o lo mueve a otro nodo.
  • Balanceo de carga y descubrimiento de servicios.
  • Actualizaciones sin tiempo de inactividad y rollbacks automáticos.
  • Gestión de secretos y configuraciones.
  • Almacenamiento persistente.

Conceptos clave de Kubernetes

Para entender cómo funciona, es importante conocer algunos de sus componentes fundamentales:

Concepto Descripción
Cluster Conjunto de máquinas (nodos) que ejecutan Kubernetes.
Nodo Una máquina (física o virtual) dentro del cluster. Puede ser master (control plane) o worker.
Pod La unidad más pequeña de despliegue. Contiene uno o más contenedores que comparten red y almacenamiento.
Deployment Define cómo se deben desplegar y actualizar los Pods.
Service Expone un conjunto de Pods como un servicio de red estable (con balanceo de carga).
Namespace Permite dividir el cluster en entornos lógicos (por ejemplo: desarrollo, producción).
ConfigMap y Secret Gestionan configuraciones y datos sensibles.

Arquitectura básica

Un cluster de Kubernetes se divide en dos partes principales:
  • Control Plane (plano de control): Es el “cerebro” del cluster. Incluye componentes como el API Server, el Scheduler, el Controller Manager y almacenamiento de la configuración.
  • Worker Nodes (nodos de trabajo): Son las máquinas donde realmente se ejecutan los Pods. Cada nodo tiene el kubelet, agente de Kubernetes y un runtime de contenedores, como containerd.

¿Qué NO es Kubernetes?

Es importante aclarar algunos malentendidos comunes:
  • No es una plataforma PaaS completa, como Heroku o Google App Engine. Es más bien una base sobre la que se pueden construir plataformas.
  • No crea contenedores, eso lo hace Docker u otros runtimes).
  • No es solo para la nube: se puede usar en servidores on-premise, en la nube o en entornos híbridos.

Ventajas de usar Kubernetes

  • Portabilidad: SE puedes ejecutar las mismas aplicaciones en cualquier entorno, como AWS, Azure, Google Cloud, etc.
  • Escalabilidad: Escala desde aplicaciones pequeñas hasta grandes sistemas.
  • Alta disponibilidad y resiliencia.
  • Ecosistema enorme: Existe una gran cantidad de herramientas, operadores y extensiones, como Helm, Istio, Prometheus, etc.
  • Declarativo: Se defines lo que se quiere hacer y Kubernetes se encarga de hacerlo realidad.

Casos de uso comunes

  • Aplicaciones basadas en microservicios.
  • Sistemas que necesitan escalar automáticamente según el tráfico.
  • Entornos de CI/CD modernos.
  • Machine Learning y procesamiento de datos a gran escala.
    • Aplicaciones que requieren alta disponibilidad y recuperación automática de fallos.

Archivos YAML de configuración en Kubernetes

Uno de los pilares de Kubernetes es su enfoque declarativo. Tú defines el estado deseado de las aplicaciones mediante archivos de configuración (llamados manifiestos), casi siempre escritos en YAML, y Kubernetes se encarga de hacerlo realidad.Estos archivos son la forma principal de crear y gestionar casi todos los objetos: "Pods, "Deployments, "Services, "ConfigMaps, "Secrets, "Ingress, etc.

Estructura básica de un manifiesto YAML

Casi todos los archivos tienen estas cuatro secciones obligatorias:

apiVersion: apps/v1          # Versión de la API
kind: Deployment             # Tipo de recurso
metadata:                    # Nombre, labels, namespace...
  name: mi-aplicacion
spec:                        # Estado deseado
  # ... configuración específica del recurso

Ejemplos de los recursos más comunes

Deployment (el más usado)

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.25
        ports:
        - containerPort: 80

Service (para exponer los Pods)yaml

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
  - port: 80
    targetPort: 80
  type: ClusterIP          # También puede ser NodePort o LoadBalancer

ConfigMap (configuración no sensible)

apiVersion: v1
kind: ConfigMap
metadata:
  name: mi-config
data:
  DATABASE_URL: "postgres://db:5432/miapp"
  LOG_LEVEL: "info"
  config.properties: |
    key1=value1
    key2=value2

Secret (datos sensibles)

apiVersion: v1
kind: Secret
metadata:
  name: mi-secret
type: Opaque
data:
  DATABASE_PASSWORD: "password-database"  # Base64 encoded

Pod simple (menos recomendado en producción, pero útil para entender)

apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
spec:
  containers:
  - name: nginx
    image: nginx:latest
    ports:
    - containerPort: 80

Cómo aplicar los archivos

# Un solo archivo
kubectl apply -f deployment.yaml

# Varios archivos
kubectl apply -f deployment.yaml -f service.yaml

# Todo un directorio
kubectl apply -f ./k8s/
Se pueden separar varios recursos en el mismo archivo usando ---:yaml 
# deployment.yaml
apiVersion: apps/v1
kind: Deployment
...
---
apiVersion: v1
kind: Service
...

Buenas prácticas recomendadas

  • Guarda siempre los ficheros YAML en Git (control de versiones).
  • Usar la última versión estable de la API (apps/v1, v1, etc.).
  • Es mejor usar YAML frente a JSON (más legible).
  • Agrupar recursos relacionados de la misma aplicación en el mismo archivo o carpeta.
  • Separar la configuración sensible en Secrets y el resto en ConfigMaps.
  • Evitar poner valores por defecto innecesarios.