Kubernetes en Linux: Guía paso a paso para orquestar contenedores

Introducción

Kubernetes se ha convertido en el estándar de facto para la orquestación de contenedores, y su integración con Linux ofrece una plataforma robusta y escalable para cargas de trabajo modernas. En este artículo exploraremos paso a paso cómo desplegar un clúster de Kubernetes en un servidor Linux, desde la preparación del sistema hasta el despliegue de tu primera aplicación.

Requisitos previos

Antes de comenzar, necesitas una distribución Linux reciente (Ubuntu 22.04 LTS, CentOS Stream 9 o Rocky Linux 9) con al menos 2 GB de RAM y 2 CPUs por nodo. Además, es fundamental tener acceso a un usuario con privilegios sudo y una conexión a internet estable para descargar los paquetes necesarios.

Instalación de las herramientas de Kubernetes

Los componentes básicos son kubeadm, kubelet y kubectl. En distribuciones basadas en Debian/Ubuntu puedes añadirlos mediante el repositorio oficial de Kubernetes:

• Actualizar el índice de paquetes: sudo apt-get update
• Instalar dependencias: sudo apt-get install -y apt-transport-https ca-certificates curl
• Añadir la clave GPG: sudo curl -fsSLo /usr/share/keyrings/kubernetes-archive-keyring.gpg https://packages.cloud.google.com/apt/doc/apt-key.gpg
• Agregar el repositorio: 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 los binarios: sudo apt-get update seguido de sudo apt-get install -y kubelet kubeadm kubectl
• Marcarlos como hold para evitar actualizaciones automáticas: sudo apt-mark hold kubelet kubeadm kubectl

Inicialización del nodo master

Con las herramientas instaladas, inicializa el plano de control con kubeadm. Elige un rango de direcciones para la red de pods (por ejemplo, 10.244.0.0/16) y ejecuta:

sudo kubeadm init --pod-network-cidr=10.244.0.0/16

Tras la finalización, copia la configuración para tu usuario:

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

Instalación de una red de pod (CNI)

Kubernetes necesita un plugin de red para que los contenedores se comuniquen. Una opción popular es Flannel:

kubectl apply -f https://github.com/flannel-io/flannel/releases/latest/download/kube-flannel.yml

Verifica que todos los nodos estén listos con kubectl get nodes.

Unir nodos workers al clúster

En cada máquina worker, ejecuta el comando de unión que kubeadm init mostró al final, algo como:

sudo kubeadm join :6443 --token --discovery-token-ca-cert-hash sha256:

Después de unir, verifica desde el master: kubectl get nodes debería mostrar todos los nodos en estado Ready.

Despliegue de una aplicación de ejemplo

Para validar el clúster, desplegaremos un servidor web sencillo usando NGINX:

• Crear un deployment: kubectl create deployment nginx --image=nginx
• Exponer el deployment como servicio: kubectl expose deployment nginx --port=80 --type=NodePort
• Obtener el puerto asignado: kubectl get svc nginx
• Acceder a través de http://: en tu navegador.

Escalado y actualizaciones

Kubernetes permite escalar aplicaciones con un solo comando:

kubectl scale deployment nginx --replicas=5

Para actualizar la imagen, por ejemplo a una versión específica de NGINX:

kubectl set image deployment/nginx nginx=nginx:1.25

El plano de control realizará un rolling update, asegurando que siempre haya réplicas disponibles.

Buenas prácticas y troubleshooting

• Mantén el sistema operativo actualizado y aplica parches de seguridad regularmente.
• Utiliza nombres de nodo descriptivos y etiquetas para organizar cargas de trabajo.
• Monitoriza el uso de recursos con kubectl top nodes y kubectl top pods.
• Revisa los logs de kubelet y del contenedor con journalctl -u kubelet y kubectl logs.
• Si un nodo no se une, verifica la conectividad del puerto 6443 y la validez del token.

Almacenamiento persistente con Volumes

Para aplicaciones que requieren estado, Kubernetes ofrece PersistentVolumes y PersistentVolumeClaims. En un entorno Linux local puedes usar el driver de hostPath para pruebas:

• Crear un PV: cat < pv-hostpath.yaml
apiVersion: v1
kind: PersistentVolume
metadata:
name: task-pv-volume
spec:
storageClassName: manual
capacity:
storage: 1Gi
accessModes:
- ReadWriteOnce
hostPath:
path: /mnt/data
EOF

• Aplicarlo: kubectl apply -f pv-hostpath.yaml
• Crear un PVC que lo consuma: cat < pvc-hostpath.yaml
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: task-pvc-claim
spec:
storageClassName: manual
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 500Mi
EOF

• Aplicar el PVC: kubectl apply -f pvc-hostpath.yaml

Luego puedes montar el claim en un pod:

cat < pod-with-volume.yaml
apiVersion: v1
kind: Pod
metadata:
name: task-pod
spec:
volumes:
- name: task-storage
persistentVolumeClaim:
claimName: task-pvc-claim
containers:
- name: task-container
image: nginx
volumeMounts:
- mountPath: /usr/share/nginx/html
name: task-storage
EOF


kubectl apply -f pod-with-volume.yaml

Conclusión

Desplegar Kubernetes en Linux es un proceso accesible que brinda gran flexibilidad para gestionar contenedores a escala. Siguiendo los pasos descritos, tendrás un clúster funcional listo para cargas de trabajo de desarrollo, pruebas o producción. Continúa explorando el ecosistema de Helm, Operadores y service meshes para potenciar aún más tu infraestructura.