Kubernetes

Kubernetes, abreviado a menudo como K8s, es un sistema de código abierto que ejecuta aplicaciones en contenedores en un clúster de máquinas. Los usuarios declaran el estado deseado de una carga de trabajo —por ejemplo, qué imagen de contenedor ejecutar, cuántas copias mantener y cuánta capacidad de CPU, memoria y GPU necesita cada copia—, y Kubernetes inicia, reinicia, traslada y escala continuamente los contenedores para ajustarse a ese estado. Google anunció el proyecto en junio de 2014, basándose en su gestor de clústeres interno Borg, y en julio de 2015, con la versión 1.0, lo ofreció como proyecto semilla de la recién creada Cloud Native Computing Foundation. El nombre significa «timonel» en griego, y K8s sustituye por un 8 las ocho letras que hay entre la K y la s. En las operaciones de aprendizaje automático (MLOps), Kubernetes es la capa habitual para ejecutar trabajos de entrenamiento distribuido, inferencia por lotes y servicio de modelos en hardware compartido.

Arquitectura y bucle de control#

Un clúster tiene un plano de control y nodos de trabajo. El plano de control contiene el servidor de API con el que se comunican todos los clientes, el almacén etcd del estado del clúster, el planificador que asigna nuevos pods a los nodos y controladores que supervisan cada uno un tipo de objeto. Todos los nodos de trabajo, ya sean servidores locales o máquinas virtuales en la nube, ejecutan un agente kubelet y un entorno de ejecución de contenedores, como containerd o CRI-O. La unidad más pequeña que programa Kubernetes es un pod: uno o varios contenedores que comparten una dirección de red y volúmenes de almacenamiento.

Las cargas de trabajo se declaran como objetos, que normalmente se escriben en YAML y se aplican con kubectl. Un Deployment mantiene en ejecución un número determinado de pods idénticos y los sustituye gradualmente cuando cambia la imagen; un Service proporciona a esos pods una dirección estable y distribuye las solicitudes entre ellos; y un Job ejecuta pods hasta que finaliza una tarea. Los controladores comparan el estado declarado con el estado real y actúan ante cualquier diferencia:

Este mismo bucle permite que Kubernetes se recupere automáticamente. Cuando falla un nodo, sus pods dejan de estar en ejecución y el controlador crea sustitutos en nodos sanos. Si un pod permanece en estado Pending por falta de capacidad, esa señal también permite que los escaladores automáticos del clúster añadan nodos.

Kubernetes para el aprendizaje automático#

Las GPU llegan a los pods mediante complementos de dispositivo, que las anuncian como un recurso cuantificable, por ejemplo nvidia.com/gpu, y mediante asignación dinámica de recursos, estable desde Kubernetes 1.34, que permite que un pod solicite dispositivos por atributos como el modelo o la memoria de la GPU. GPU Operator de NVIDIA instala controladores y complementos en los nodos con GPU, y puede dividir una GPU en particiones Multi-Instance GPU o compartirla en el tiempo entre varios pods. En 2021, OpenAI informó de que había escalado clústeres individuales de Kubernetes hasta 7500 nodos para entrenar modelos como GPT-3 y CLIP.

Los proyectos de código abierto añaden capas específicas de aprendizaje automático:

• Kubeflow: Ejecuta entrenamiento distribuido de PyTorch, flujos de trabajo de aprendizaje automático y cuadernos en un clúster.
• Kueue: Pone en cola los trabajos por lotes y de entrenamiento, y aplica cuotas por equipo para que las costosas GPU estén siempre ocupadas sin que un equipo acapare todas.
• KServe: Sirve modelos a través de puntos de conexión con escalado automático, incluida la reducción a cero para los modelos inactivos.
• Escalador horizontal automático de pods: Añade o elimina réplicas de inferencia según el uso de CPU o métricas personalizadas, como la longitud de la cola, para mantener estable la latencia cuando cambia el tráfico.

Un Job es la forma más sencilla de ejecutar una tarea puntual en la GPU, como la inferencia por lotes. La imagen oficial de Docker de Ultralytics ya incluye el comando yolo y los pesos de YOLO26 nano, por lo que este Job solo establece un comando y solicita una GPU:

apiVersion: batch/v1
kind: Job
metadata:
  name: yolo26-predict
spec:
  backoffLimit: 2 # retry a failed pod at most twice
  template:
    spec:
      restartPolicy: Never
      containers:
        - name: yolo
          image: ultralytics/ultralytics:latest
          command: ["yolo", "predict", "model=yolo26n.pt", "source=https://ultralytics.com/images/bus.jpg"]
          resources:
            limits:
              nvidia.com/gpu: 1 # schedule only onto a node with a free GPU

kubectl apply -f job.yaml lo envía, el planificador coloca el pod en un nodo con una GPU libre y kubectl logs job/yolo26-predict muestra los resultados de detección de objetos del modo de predicción. Un Job de entrenamiento sigue el mismo patrón y añade un volumen persistente para los puntos de control, además de un volumen en memoria en /dev/shm para los trabajadores del cargador de datos de PyTorch.

Kubernetes frente a Docker y la computación sin servidor#

• Docker: Crea imágenes y ejecuta contenedores en una sola máquina. Kubernetes distribuye contenedores entre muchas máquinas y, desde la versión 1.24, ejecuta imágenes creadas con Docker mediante containerd o CRI-O, en lugar de Docker Engine.
• Computación sin servidor: Servicios como Google Cloud Run y AWS Lambda ocultan por completo el clúster y cobran por solicitud; Knative incorpora el mismo modelo de escalado a cero a los clústeres de Kubernetes.
• Kubernetes gestionado: Google Kubernetes Engine (GKE), Amazon Elastic Kubernetes Service (EKS) y Azure Kubernetes Service (AKS) ejecutan el plano de control para sus clientes, y GKE Autopilot también gestiona los nodos de trabajo.