Qué es Kubernetes y Para Qué Sirve: Guía Completa para Principiantes

Introducción

Has aprendido a usar Docker y los contenedores, pero ahora te preguntas: “¿Cómo gestiono decenas o cientos de contenedores en producción?”. La respuesta es Kubernetes, frecuentemente abreviado como K8s. En esta guía te explicaré qué es, cómo funciona y cuándo tiene sentido usarlo.

¿Qué es Kubernetes?

Kubernetes es una plataforma de código abierto para la orquestación de contenedores. Fue creada por Google en 2014 basándose en 15 años de experiencia gestionando contenedores a gran escala, y ahora es mantenida por la Cloud Native Computing Foundation (CNCF).

Pero, ¿qué significa “orquestación”? Imagina una orquesta sinfónica:

• Los músicos son tus contenedores, cada uno sabe tocar su instrumento
• El director de orquesta es Kubernetes, que coordina a todos los músicos
• La partitura es la configuración que define cómo deben tocar juntos

Sin un director, cada músico tocaría por su cuenta. Con Kubernetes, todos los contenedores trabajan en armonía para hacer funcionar tu aplicación.

El Nombre Kubernetes

El nombre proviene del griego κυβερνήτης (kybernetes), que significa “timonel” o “piloto”. El logo con el timón de siete radios representa precisamente este concepto. La abreviación K8s surge del hecho de que hay 8 letras entre la “K” y la “s”.

¿Por Qué Se Necesita Kubernetes?

Docker resuelve el problema de crear y ejecutar contenedores individuales. Pero en producción las cosas se complican:

• ¿Qué pasa si un contenedor falla a las 3 de la madrugada?
• ¿Cómo distribuyes el tráfico entre 10 instancias de la misma aplicación?
• ¿Cómo actualizas la aplicación sin tiempo de inactividad?
• ¿Cómo gestionas 50 microservicios que necesitan comunicarse entre sí?

Kubernetes responde a todas estas preguntas.

Docker vs Kubernetes: No Son Alternativos

Un malentendido común es pensar que Kubernetes reemplaza a Docker. En realidad trabajan juntos:

Kubernetes puede usar Docker (u otros runtimes como containerd) para ejecutar los contenedores. No tienes que elegir entre uno u otro: los usas ambos.

Para Qué Sirve Kubernetes: 6 Problemas que Resuelve

1. Self-Healing: Contenedores que Se Reparan Solos

Si un contenedor falla, Kubernetes lo detecta y automáticamente inicia uno nuevo. No hace falta que alguien esté despierto a las 3 de la madrugada para reiniciar manualmente los servicios.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# Kubernetes garantiza siempre 3 réplicas activas
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
spec:
  replicas: 3  # Si una muere, K8s crea una nueva
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      containers:
      - name: web
        image: nginx:latest

2. Escalado Automático

¿Tienes un pico de tráfico? Kubernetes puede aumentar automáticamente el número de contenedores. ¿El tráfico baja? Los reduce para ahorrar recursos.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# Escala automáticamente entre 2 y 10 réplicas según la CPU
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: web-app-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: web-app
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70

3. Balanceo de Carga Integrado

Kubernetes distribuye automáticamente el tráfico entre todos los contenedores disponibles. Si un contenedor está sobrecargado o no responde, el tráfico se redirige a los demás.

4. Rolling Updates: Actualizaciones Sin Tiempo de Inactividad

Cuando despliegas una nueva versión, Kubernetes:

1. Inicia los nuevos contenedores con la versión actualizada
2. Verifica que funcionen correctamente
3. Gradualmente transfiere el tráfico a los nuevos contenedores
4. Termina los contenedores antiguos

Si algo sale mal, puede hacer rollback automático a la versión anterior.

5. Service Discovery

En un sistema con muchos microservicios, ¿cómo encuentra el servicio A al servicio B? Kubernetes proporciona un sistema DNS interno: cada servicio tiene un nombre y Kubernetes se encarga de traducirlo a la dirección correcta.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# El servicio "database" será accesible como "database.default.svc.cluster.local"
apiVersion: v1
kind: Service
metadata:
  name: database
spec:
  selector:
    app: postgres
  ports:
  - port: 5432

6. Gestión de Secrets y Configuraciones

Contraseñas, API keys, configuraciones: Kubernetes los gestiona de forma segura y los inyecta en los contenedores sin hardcodearlos en el código.

1
2
3
4
5
6
7
8
9

# Secret para las credenciales de la base de datos
apiVersion: v1
kind: Secret
metadata:
  name: db-credentials
type: Opaque
data:
  username: YWRtaW4=      # codificado en base64
  password: cGFzc3dvcmQ=  # codificado en base64

Conceptos Fundamentales de Kubernetes

Pod

El Pod es la unidad básica de Kubernetes. Contiene uno o más contenedores que comparten red y almacenamiento. En la mayoría de los casos, un Pod contiene un solo contenedor.

Node

Un Node es una máquina (física o virtual) que ejecuta los Pods. Un cluster de Kubernetes típicamente tiene varios Nodes para garantizar alta disponibilidad.

Cluster

El Cluster es el conjunto de todos los Nodes gestionados por Kubernetes. Incluye:

• Control Plane: el “cerebro” que toma decisiones (dónde colocar los Pods, cuándo escalarlos, etc.)
• Worker Nodes: las máquinas que realmente ejecutan los contenedores

Deployment

Un Deployment describe el estado deseado de tu aplicación: qué imagen usar, cuántas réplicas, cómo actualizarla. Kubernetes se asegura de que el estado real corresponda siempre al estado deseado.

Service

Un Service expone los Pods a la red. Proporciona una dirección IP estable y balanceo de carga, incluso cuando los Pods subyacentes cambian.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

┌─────────────────────────────────────────────────────────┐
│                      CLUSTER                            │
│  ┌─────────────────────────────────────────────────┐   │
│  │              CONTROL PLANE                       │   │
│  │  • API Server  • Scheduler  • Controller        │   │
│  └─────────────────────────────────────────────────┘   │
│                                                         │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐    │
│  │   NODE 1    │  │   NODE 2    │  │   NODE 3    │    │
│  │ ┌─────────┐ │  │ ┌─────────┐ │  │ ┌─────────┐ │    │
│  │ │  Pod A  │ │  │ │  Pod A  │ │  │ │  Pod B  │ │    │
│  │ └─────────┘ │  │ └─────────┘ │  │ └─────────┘ │    │
│  │ ┌─────────┐ │  │ ┌─────────┐ │  │ ┌─────────┐ │    │
│  │ │  Pod B  │ │  │ │  Pod C  │ │  │ │  Pod C  │ │    │
│  │ └─────────┘ │  │ └─────────┘ │  │ └─────────┘ │    │
│  └─────────────┘  └─────────────┘  └─────────────┘    │
└─────────────────────────────────────────────────────────┘

Kubernetes vs Docker Swarm

Docker tiene su propio orquestador integrado: Docker Swarm. ¿Cuál es la diferencia?

Cuándo elegir Docker Swarm:

• Proyectos pequeños/medianos
• Equipos con poca experiencia en orquestación
• Necesidad de empezar rápidamente

Cuándo elegir Kubernetes:

• Proyectos empresariales o en crecimiento
• Necesidad de funcionalidades avanzadas
• Equipo dispuesto a invertir en aprendizaje
• Requisitos de escalado importantes

Cuándo NO Usar Kubernetes

Kubernetes no siempre es la respuesta correcta. Evítalo si:

• Tienes pocos contenedores: gestionar 2-3 contenedores con K8s es como usar un camión para llevar la compra
• El equipo es pequeño: la complejidad operacional puede superar los beneficios
• La aplicación es monolítica: K8s brilla con los microservicios
• No tienes requisitos de escalado: si el tráfico es constante y predecible, podrías no necesitarlo
• Presupuesto limitado: los clusters de Kubernetes tienen costes operacionales significativos

Alternativas Más Simples

Cómo Empezar con Kubernetes

Si quieres explorar Kubernetes sin volverte loco, aquí tienes un camino gradual:

1. Aprende los Fundamentos de Docker

Si aún no lo has hecho, empieza con Docker. Kubernetes orquesta contenedores, así que primero necesitas saber crearlos.

2. Experimenta en Local con Minikube

Minikube crea un cluster de Kubernetes en tu ordenador. Perfecto para aprender sin costes de cloud.

1
2
3
4
5

# Instala Minikube e inicia un cluster local
minikube start

# Verifica que funciona
kubectl get nodes

3. Explora kubectl

kubectl es el comando para interactuar con Kubernetes. Aprende las operaciones básicas:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Ver los Pods en ejecución
kubectl get pods

# Crear recursos desde un archivo YAML
kubectl apply -f deployment.yaml

# Ver los logs de un Pod
kubectl logs nombre-pod

# Entrar en un contenedor
kubectl exec -it nombre-pod -- /bin/bash

4. Prueba un Cluster Gestionado

Cuando estés listo para producción, usa un servicio gestionado:

• Google Kubernetes Engine (GKE)
• Amazon Elastic Kubernetes Service (EKS)
• Azure Kubernetes Service (AKS)

Estos servicios gestionan el Control Plane por ti, reduciendo la complejidad operacional.

Conclusiones

Kubernetes es una herramienta potente que resuelve problemas reales en la gestión de aplicaciones containerizadas a gran escala. Ofrece self-healing, escalado automático, despliegues sin tiempo de inactividad y mucho más.

Sin embargo, trae consigo una complejidad significativa. Antes de adoptarlo, pregúntate:

• ¿Realmente necesito orquestar muchos contenedores?
• ¿Mi equipo tiene las competencias (o el tiempo para adquirirlas)?
• ¿Los beneficios justifican la complejidad añadida?

Si la respuesta es sí, Kubernetes puede transformar la forma en que gestionas tus aplicaciones. Si no, soluciones más simples como Docker Compose o Docker Swarm podrían ser la mejor elección.

El consejo es empezar en pequeño: experimenta con Minikube, practica con los conceptos básicos, y escala gradualmente hacia clusters más complejos cuando realmente lo necesites.