Kubernetes Docker DevOps

Kubernetes: orquestación de contenedores paso a paso

Kubernetes resuelve un problema real: gestionar decenas de contenedores en producción es caótico sin un orquestador. Esta guía explica su arquitectura, sus componentes y te lleva desde cero hasta un servicio expuesto en Minikube.

Jean Michael Estevez Alvarez 26 abr 2026 · 9 min de lectura

Anatomía de un clúster Kubernetes: el Control Plane gestiona el estado deseado; los Worker Nodes ejecutan los Pods con sus contenedores.

¿Qué problema resuelve Kubernetes?

Con un solo servidor y un par de contenedores Docker, docker run es suficiente. El problema aparece cuando tienes diez servicios, necesitas escalar el procesador de pagos en Black Friday sin tocar el resto, quieres que si un contenedor muere otro arranque solo, y además tienes que actualizar la app sin tiempo de inactividad. Eso es exactamente lo que Kubernetes orquesta.

Kubernetes (K8s) es un sistema de orquestación de contenedores de código abierto creado por Google en 2014 y cedido a la CNCF. Abstrae la infraestructura subyacente y expone una API declarativa: tú describes el estado deseado («quiero 3 réplicas de este servicio»), y K8s trabaja continuamente para mantener ese estado.

Componentes clave

El clúster se divide en dos planos:

Control Plane — cerebro del clúster. Compuesto por el API Server (punto de entrada de toda comunicación), etcd (base de datos clave-valor que almacena el estado), el Scheduler (decide en qué nodo corre cada Pod) y el Controller Manager (bucle de reconciliación que aplica cambios).
Worker Nodes — máquinas donde corren las cargas. Cada nodo tiene kubelet (agente que habla con el API Server), kube-proxy (gestiona reglas de red) y un runtime de contenedores (Docker, containerd, CRI-O).

La unidad mínima desplegable es el Pod: uno o más contenedores que comparten red y almacenamiento, siempre co-localizados en el mismo nodo.

Instalación con Minikube (entorno local)

Minikube levanta un clúster de un solo nodo en tu máquina, ideal para aprender y desarrollar.

# Instalar Minikube (Linux/macOS con Homebrew)
brew install minikube

# Instalar kubectl
brew install kubectl

# Levantar el clúster (usa Docker como driver por defecto)
minikube start

# Verificar que el clúster está listo
kubectl cluster-info
kubectl get nodes

En Windows puedes usar winget install Kubernetes.minikube y winget install Kubernetes.kubectl. Una vez arrancado, kubectl get nodes debe devolver el nodo con estado Ready.

Primer deployment

Un Deployment es el objeto de K8s que gestiona réplicas de Pods y controla las actualizaciones. Puedes crearlo de dos formas: imperativa (rápida para pruebas) o declarativa con un manifiesto YAML (la forma correcta para producción).

# Forma imperativa — útil para explorar
kubectl create deployment hello-web \
  --image=nginx:1.25 \
  --replicas=2

# Verificar
kubectl get deployments
kubectl get pods

El equivalente en YAML, que deberías versionar en tu repositorio:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-web
  labels:
    app: hello-web
spec:
  replicas: 2
  selector:
    matchLabels:
      app: hello-web
  template:
    metadata:
      labels:
        app: hello-web
    spec:
      containers:
        - name: nginx
          image: nginx:1.25
          ports:
            - containerPort: 80
          resources:
            requests:
              cpu: "100m"
              memory: "64Mi"
            limits:
              cpu: "250m"
              memory: "128Mi"

# Aplicar el manifiesto
kubectl apply -f deployment.yaml

# Ver eventos de despliegue
kubectl rollout status deployment/hello-web

Flujo completo de kubectl apply: el YAML llega al API Server, se persiste en etcd, el Scheduler asigna nodo, y kubelet crea el Pod.

Exponer el servicio

Un Pod tiene IP interna efímera. Para que sea accesible se usa un Service, que actúa como balanceador de carga estable frente al grupo de Pods.

apiVersion: v1
kind: Service
metadata:
  name: hello-web-svc
spec:
  selector:
    app: hello-web        # apunta a los Pods con este label
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  type: NodePort          # en Minikube; en cloud usar LoadBalancer

kubectl apply -f service.yaml

# En Minikube, abrir en el navegador directamente:
minikube service hello-web-svc

Para clusters en la nube (GKE, EKS, AKS) se usa type: LoadBalancer y el proveedor provisiona una IP pública automáticamente. Para dominios personalizados y TLS, se agrega un Ingress con un Ingress Controller como nginx.

Escalar y actualizar sin downtime

# Escalar a 5 réplicas
kubectl scale deployment hello-web --replicas=5

# Actualizar imagen (rolling update automático)
kubectl set image deployment/hello-web nginx=nginx:1.26

# Ver progreso del rolling update
kubectl rollout status deployment/hello-web

# Revertir si algo salió mal
kubectl rollout undo deployment/hello-web

Por defecto K8s usa una estrategia RollingUpdate: levanta Pods nuevos antes de terminar los viejos, garantizando disponibilidad continua. Puedes configurar maxUnavailable y maxSurge en la spec del Deployment para controlar la velocidad del proceso.

Namespaces y organización

Los Namespaces son particiones lógicas del clúster. Permiten aislar equipos, entornos (dev/staging/prod) o aplicaciones sin necesitar clústeres separados. Cada recurso existe dentro de un namespace.

# Crear namespace para el entorno de staging
kubectl create namespace staging

# Desplegar en ese namespace
kubectl apply -f deployment.yaml -n staging

# Ver todos los recursos de staging
kubectl get all -n staging

Próximos pasos

ConfigMaps y Secrets — externalizar configuración y credenciales de los contenedores.
Persistent Volumes — almacenamiento persistente para bases de datos y archivos de estado.
Horizontal Pod Autoscaler (HPA) — escalar automáticamente según CPU/memoria o métricas personalizadas.
Helm — gestor de paquetes para K8s; empaqueta, versiona y comparte manifiestos como charts.
Observabilidad — stack Prometheus + Grafana para métricas, Loki para logs, Jaeger para trazas distribuidas.