Los fundamentos de Kubernetes: guía completa para orquestar tus contenedores

Kubernetes (K8s) se ha convertido en la plataforma estándar para la orquestación de contenedores a gran escala. Esta guía te presenta los conceptos fundamentales de Kubernetes y cómo utilizarlo eficazmente para gestionar tus aplicaciones en contenedores.

¿Qué es Kubernetes?

Kubernetes es una plataforma de código abierto creada por Google para automatizar el despliegue, el escalado y la gestión de aplicaciones en contenedores. Proporciona un marco para ejecutar sistemas distribuidos de forma resiliente.

¿Por qué Kubernetes?

• Despliegue automatizado: despliegue y actualizaciones sin tiempo de inactividad
• Autorreparación: reinicio automático de los contenedores que fallan
• Escalado horizontal: adaptación automática de la capacidad
• Equilibrio de carga: distribución del tráfico entre las instancias
• Orquestación del almacenamiento: gestión del almacenamiento persistente
• Gestión de la configuración: separación del código y la configuración
• Soporte multinube: funciona en todos los principales proveedores cloud

Arquitectura de Kubernetes

La arquitectura de Kubernetes se compone de varios componentes clave:

Plano de control (Control Plane)

• API Server: punto de entrada para todos los comandos REST
• etcd: base de datos clave-valor para almacenar el estado del clúster
• Scheduler: asigna los pods a los nodos
• Controller Manager: mantiene el estado deseado del clúster
• Cloud Controller Manager: interfaz con las APIs de los proveedores cloud

Nodos (Nodes)

• Kubelet: agente que se ejecuta en cada nodo y se asegura de que los contenedores funcionen
• Kube-proxy: mantiene las reglas de red en los nodos
• Container Runtime: software responsable de la ejecución de los contenedores (Docker, containerd, etc.)

Instalación de Kubernetes

Minikube (para desarrollo local)

# Instalación en Linux
curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
sudo install minikube-linux-amd64 /usr/local/bin/minikube

# Iniciar un clúster Kubernetes local
minikube start

# Comprobar el estado
minikube status

kubeadm (para clústeres de producción)

# Instalación de los requisitos previos
sudo apt-get update
sudo apt-get install -y apt-transport-https ca-certificates curl

# Añadir la clave GPG y el repositorio de Kubernetes
sudo curl -fsSLo /usr/share/keyrings/kubernetes-archive-keyring.gpg https://packages.cloud.google.com/apt/doc/apt-key.gpg
echo "deb [signed-by=/usr/share/keyrings/kubernetes-archive-keyring.gpg] https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list

# Instalar kubeadm, kubelet y kubectl
sudo apt-get update
sudo apt-get install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl

# Inicializar el clúster (en el nodo maestro)
sudo kubeadm init --pod-network-cidr=192.168.0.0/16

# Configurar kubectl
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

kubectl (herramienta de línea de comandos)

# Instalación en Linux
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl

# Comprobar la instalación
kubectl version --client

Conceptos fundamentales de Kubernetes

Pods

El pod es la unidad básica de Kubernetes y representa uno o varios contenedores que comparten almacenamiento y red.

# pod.yaml - Ejemplo de pod sencillo
apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
  labels:
    app: nginx
spec:
  containers:
  - name: nginx
    image: nginx:1.19
    ports:
    - containerPort: 80

# Crear un pod
kubectl apply -f pod.yaml

# Listar los pods
kubectl get pods

# Describir un pod
kubectl describe pod nginx-pod

# Eliminar un pod
kubectl delete pod nginx-pod

Deployments

Los deployments permiten gestionar el ciclo de vida de los pods y de los ReplicaSets, y facilitan las actualizaciones y los rollbacks.

# deployment.yaml - Ejemplo de despliegue
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.19
        ports:
        - containerPort: 80

# Crear un despliegue
kubectl apply -f deployment.yaml

# Listar los despliegues
kubectl get deployments

# Actualizar la imagen de un despliegue
kubectl set image deployment/nginx-deployment nginx=nginx:1.20

# Realizar un rollback
kubectl rollout undo deployment/nginx-deployment

Services

Los services permiten exponer las aplicaciones que se ejecutan en un conjunto de pods.

# service.yaml - Ejemplo de service
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
  - port: 80
    targetPort: 80
  type: ClusterIP  # Otros tipos: NodePort, LoadBalancer, ExternalName

# Crear un service
kubectl apply -f service.yaml

# Listar los services
kubectl get services

# Describir un service
kubectl describe service nginx-service

Namespaces

Los namespaces proporcionan un mecanismo para aislar grupos de recursos dentro de un clúster.

# namespace.yaml - Ejemplo de namespace
apiVersion: v1
kind: Namespace
metadata:
  name: development

# Crear un namespace
kubectl apply -f namespace.yaml

# Listar los namespaces
kubectl get namespaces

# Crear un recurso en un namespace concreto
kubectl apply -f pod.yaml -n development

ConfigMaps y Secrets

Permiten separar la configuración de los contenedores.

# configmap.yaml - Ejemplo de ConfigMap
apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  database.host: "db.example.com"
  database.port: "5432"

# secret.yaml - Ejemplo de Secret
apiVersion: v1
kind: Secret
metadata:
  name: app-secrets
type: Opaque
data:
  # Los valores deben estar codificados en base64
  database.password: cGFzc3dvcmQxMjM=  # "password123" codificado en base64

# Crear un ConfigMap
kubectl apply -f configmap.yaml

# Crear un Secret
kubectl apply -f secret.yaml

# Usar un ConfigMap en un pod
spec:
  containers:
  - name: app
    image: app:1.0
    envFrom:
    - configMapRef:
        name: app-config

Uso de volúmenes

Los volúmenes permiten almacenar datos más allá de la vida útil de un pod.

# pvc.yaml - Ejemplo de PersistentVolumeClaim
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: data-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi

# pod-with-volume.yaml - Pod que utiliza un volumen
apiVersion: v1
kind: Pod
metadata:
  name: data-pod
spec:
  containers:
  - name: data-container
    image: nginx
    volumeMounts:
    - mountPath: "/data"
      name: data-volume
  volumes:
  - name: data-volume
    persistentVolumeClaim:
      claimName: data-pvc

Gestión del Ingress

El Ingress expone los servicios HTTP y HTTPS desde el exterior del clúster.

# ingress.yaml - Ejemplo de Ingress
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: example-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  rules:
  - host: example.com
    http:
      paths:
      - path: /app
        pathType: Prefix
        backend:
          service:
            name: app-service
            port:
              number: 80

# Instalar un controlador Ingress (ejemplo con NGINX)
kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.0.0/deploy/static/provider/cloud/deploy.yaml

# Crear un Ingress
kubectl apply -f ingress.yaml

Depuración de aplicaciones

Logs y shell interactivo

# Mostrar los logs de un pod
kubectl logs nginx-pod

# Ejecutar un comando en un pod
kubectl exec -it nginx-pod -- /bin/bash

# Seguir los logs en tiempo real
kubectl logs -f nginx-pod

Diagnóstico de problemas

# Comprobar el estado de un pod
kubectl get pod nginx-pod -o wide

# Describir un pod para ver los eventos
kubectl describe pod nginx-pod

# Comprobar los nodos
kubectl get nodes
kubectl describe node <node-name>

Gestión de recursos

Límites de recursos

# resource-limits.yaml - Ejemplo de límites de recursos
apiVersion: v1
kind: Pod
metadata:
  name: resource-pod
spec:
  containers:
  - name: app
    image: app:1.0
    resources:
      requests:
        memory: "64Mi"
        cpu: "250m"
      limits:
        memory: "128Mi"
        cpu: "500m"

Horizontal Pod Autoscaler (HPA)

# hpa.yaml - Ejemplo de autoescalado
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: app-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: app-deployment
  minReplicas: 1
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 50

# Crear un HPA
kubectl apply -f hpa.yaml

# Listar los HPA
kubectl get hpa

Seguridad en Kubernetes

RBAC (control de acceso basado en roles)

# role.yaml - Ejemplo de rol
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  namespace: default
  name: pod-reader
rules:
- apiGroups: [""]
  resources: ["pods"]
  verbs: ["get", "watch", "list"]

# rolebinding.yaml - Ejemplo de asociación de rol
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: read-pods
  namespace: default
subjects:
- kind: User
  name: jane
  apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: Role
  name: pod-reader
  apiGroup: rbac.authorization.k8s.io

Network Policies

# network-policy.yaml - Ejemplo de política de red
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: db-network-policy
spec:
  podSelector:
    matchLabels:
      role: db
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          role: app
    ports:
    - protocol: TCP
      port: 5432

Mejores prácticas para Kubernetes

1. Utilizar deployments en lugar de pods individuales
2. Definir límites de recursos para todos los contenedores
3. Configurar sondas de disponibilidad (liveness y readiness probes)
4. Implementar el escalado horizontal para cargas variables
5. Separar los entornos con namespaces
6. Utilizar labels y annotations para organizar los recursos
7. Implementar políticas de red para proteger las comunicaciones
8. Configurar el RBAC para limitar los accesos
9. Utilizar Secrets para los datos sensibles
10. Establecer una estrategia de copias de seguridad para etcd

Herramientas complementarias para Kubernetes

Helm (gestor de paquetes)

# Instalación de Helm
curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3
chmod 700 get_helm.sh
./get_helm.sh

# Añadir un repositorio
helm repo add bitnami https://charts.bitnami.com/bitnami

# Instalar una aplicación
helm install my-release bitnami/wordpress

Kustomize (gestión de la configuración)

# kustomization.yaml - Ejemplo de configuración de Kustomize
resources:
- deployment.yaml
- service.yaml

namespace: my-namespace

commonLabels:
  app: my-app
  environment: production

# Aplicar una configuración de Kustomize
kubectl apply -k ./

Prometheus y Grafana (monitorización)

# Instalación mediante Helm
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm install prometheus prometheus-community/kube-prometheus-stack

Conclusión

Kubernetes se ha convertido en la herramienta estándar para la orquestación de contenedores gracias a su flexibilidad, su robustez y su rico ecosistema. Comprender sus conceptos fundamentales es esencial para gestionar con eficacia aplicaciones modernas a gran escala.

Si dominas Kubernetes, podrás:

• Desplegar aplicaciones a escala
• Garantizar una alta disponibilidad
• Optimizar el uso de los recursos
• Simplificar las operaciones
• Ofrecer un modelo declarativo para la gestión de la infraestructura

La curva de aprendizaje de Kubernetes puede ser pronunciada, pero la inversión merece la pena para cualquier equipo que trabaje con arquitecturas basadas en contenedores.