# Kubernetes

## Qué es

Kubernetes, a menudo escrito K8s, es software de código abierto que ejecuta aplicaciones en contenedores sobre un grupo de máquinas, llamado clúster, y las mantiene de acuerdo con una descripción que usted proporciona: qué imagen ejecuta cada aplicación, cuántas copias existen, cuánta memoria y CPU puede utilizar cada copia y cómo acceden a ella otros programas. La documentación del proyecto lo llama «una plataforma de código abierto, portátil y extensible, para gestionar cargas de trabajo y servicios en contenedores». El nombre significa timonel o piloto en griego; K8s conserva la K y la s y sustituye las ocho letras intermedias por su número; Google publicó el proyecto como código abierto en 2014.

Un clúster tiene dos mitades. El plano de control conserva la descripción: el servidor de API es la única interfaz HTTP por la que pasa todo cambio, etcd almacena lo que se le indica, el planificador asigna cada Pod nuevo a un nodo adecuado y el gestor de controladores ejecuta los bucles que actúan sobre la descripción. En cada nodo de trabajo, kubelet se asegura de que los Pods asignados estén en ejecución, kube-proxy mantiene las reglas de red de los Services y un entorno de ejecución de contenedores, como containerd o CRI-O, inicia los contenedores. Docker Engine dejó de ser un entorno de ejecución integrado en Kubernetes 1.24, y las imágenes construidas con Docker se ejecutan sin cambios porque son imágenes OCI estándar.

La descripción es un conjunto de objetos, normalmente escritos en YAML. Un Pod es la unidad más pequeña que planifica Kubernetes: uno o varios contenedores que comparten una dirección de red y almacenamiento en una máquina. Un [Deployment](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/) indica cuántos Pods idénticos deben existir y los sustituye paso a paso cuando cambia su plantilla. Un Service da un nombre y una dirección estables a un conjunto cambiante de Pods, seleccionando sus miembros por etiqueta. Una aplicación web pequeña tiene este aspecto:

```text
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      containers:
        - name: web
          image: registry.example.com/web:1.4.2
          resources:
            requests:
              cpu: 250m
              memory: 256Mi
            limits:
              memory: 256Mi
          readinessProbe:
            httpGet:
              path: /healthz
              port: 8080
```

Suele compararse con tres opciones más pequeñas. Docker Compose describe contenedores en una máquina y, cuando esta desaparece, también desaparecen ellos. Un gestor de servicios como systemd puede reiniciar un contenedor que falle y ponerlo en marcha al arrancar, lo que cubre muchas necesidades con mucha menos maquinaria, pero no sabe trasladar el trabajo a otra máquina. Las plataformas alojadas, como Google Cloud Run o Azure Container Apps, ejecutan contenedores sin entregarle un plano de control que deba operar, a cambio de ofrecer menos ajustes. La documentación también es clara sobre lo que Kubernetes no es: una plataforma como servicio tradicional que lo incluya todo. No construye su aplicación ni proporciona bases de datos o colas de mensajes propias.

## Por qué importa

La idea central es que el clúster trabaja continuamente para ajustarse a una descripción escrita, en lugar de ejecutar una lista de órdenes una vez. Aplicar el archivo anterior no inicia nada directamente: registra un deseo. Los controladores son bucles de control que observan el clúster y actúan para acercar el estado actual al deseado. Si una máquina falla y tres copias pasan a ser dos, un controlador detecta la diferencia, se crea un Pod nuevo y el planificador lo sitúa en una máquina con capacidad. Como la descripción es un conjunto de archivos, puede residir en un repositorio y pasar por la misma revisión que el código que ejecuta.

La plataforma incorpora los despliegues de versiones. La estrategia predeterminada es una actualización gradual: se inician Pods nuevos y los antiguos se detienen a medida que los nuevos están listos, dentro de límites que, de forma predeterminada, permiten hasta un 25 % de Pods adicionales y hasta un 25 % no disponibles en cualquier momento. Cada cambio de la plantilla del Pod se conserva como revisión —diez de forma predeterminada—, y `kubectl rollout undo` vuelve a la anterior. El script que antes retiraba el tráfico de un servidor, sustituía un binario y lo reincorporaba se convierte en comportamiento integrado.

El planificador también cambia la economía del conjunto de máquinas. Sitúa cada Pod según la CPU y la memoria que solicita, por lo que muchos servicios pequeños comparten máquinas en lugar de recibir cada uno un servidor dimensionado para su peor día.

El coste es real. Un clúster es en sí mismo un sistema distribuido, con versiones que actualizar según un calendario, una capa de red, otra de almacenamiento, certificados y control de acceso, todo lo cual alguien debe entender cuando falla. Las ofertas gestionadas, como Google Kubernetes Engine, Amazon EKS y Azure Kubernetes Service, ejecutan el plano de control por usted, pero todos los manifiestos y, normalmente, los nodos de trabajo siguen siendo su responsabilidad. Para unos pocos servicios en una o dos máquinas, un gestor de servicios sencillo suele cumplir la función con menos piezas.

## Cómo se aplica en la práctica

[La página de tecnologías de la empresa](/es/tech-stack/) expresa la regla claramente: Docker y Kubernetes para las cargas de trabajo que lo justifican, y unidades systemd sencillas para las demás. Kubernetes se elige para cada carga según el tamaño y la naturaleza del trabajo, no como opción predeterminada.

Un encargo muestra cargas que lo justificaban.
[Se desplegaron y mantuvieron veinte aplicaciones Docker en Google Cloud y AWS](/es/portfolio/ran-20-docker-apps-on-google-cloud-and-aws/),
entre ellas aplicaciones de analítica basadas en R, con configuración y monitorización coherentes para que ninguna se convirtiera en un caso especial. La resolución de problemas se hacía mediante Podman y la depuración de la orquestación mediante Kubernetes. La página informa de diagnósticos más rápidos y despliegues estables y reproducibles.

La otra mitad de la regla aparece en la plataforma propia de la empresa. [Una capa de contenedores basada en Podman y Quadlet](/es/portfolio/ran-containers-on-podman-and-quadlet/) ejecuta cada contenedor como un servicio del supervisor del propio sistema operativo, descrito con la misma forma declarativa que todo lo demás en el host. Los contenedores utilizan la red del host y no publican puertos, de modo que las reglas del cortafuegos instaladas por el rol de refuerzo de seguridad siguen al mando. Donde Kubernetes distribuiría una imagen nueva mediante su API, un usuario de despliegue sin root ejecuta un único script fijo que construye la imagen y reinicia el servicio. En un host, eso da a cada contenedor una descripción escrita y el supervisor en el que el host ya confía, sin un segundo gestor de procesos. Lo que deja fuera es la distribución entre máquinas y la sustitución de un nodo que falla, que es donde Kubernetes empieza a compensar su peso.

## Dónde surgen los problemas

La mayoría de los problemas de Kubernetes proceden de la distancia entre lo que pide un manifiesto y lo que informa el clúster.

**Un despliegue queda a medias mientras la tarea de despliegue informa de éxito.** Cuando los Pods nuevos nunca están listos, por una etiqueta de imagen incorrecta, un fallo al arrancar, una sonda de disponibilidad que falla o falta de cuota, el Deployment deja de avanzar. Tras el plazo de progreso, cuyo valor predeterminado es 600 segundos, registra el motivo `ProgressDeadlineExceeded`, y la documentación indica que Kubernetes no hace nada más: los Pods antiguos que siguen en ejecución continúan atendiendo y nada revierte por sí solo. `kubectl rollout status` termina con un código distinto de cero cuando vence el plazo, por lo que un paso de despliegue puede esperarlo y revertir la versión:

```sh
kubectl apply -f web.yaml
kubectl rollout status deployment/web --timeout=10m \
  || kubectl rollout undo deployment/web
```

**Un contenedor se reinicia con `OOMKilled` o se ralentiza en un nodo con CPU libre.** El núcleo hace cumplir los límites y ambos recursos se comportan de forma distinta. Un contenedor que supera su límite de memoria puede terminarse y reiniciarse; al alcanzar su límite de CPU se restringe su uso, por lo que se ralentiza sin terminar, lo que parece un problema de la aplicación. El planificador sitúa los Pods según lo que solicitan, no lo que consumen: peticiones bajas saturan un nodo y las altas dejan máquinas ociosas. Un límite especificado sin petición se convierte en la petición. Ajuste la memoria al uso medido y trate los límites de CPU como una decisión deliberada.

**Se fuerza la terminación de una aplicación de arranque lento antes de que complete el inicio.** Una sonda de vitalidad que falla hace que kubelet termine y reinicie el contenedor, por lo que una aplicación que necesita un minuto para cargar y se comprueba a los diez segundos se reinicia indefinidamente. Una sonda de arranque aplaza las demás comprobaciones hasta que la aplicación funciona. Una sonda de disponibilidad retira un Pod de su Service sin reiniciarlo, lo que encaja con un Pod ocupado o que está calentando una caché. Una sonda de vitalidad que consulta la base de datos reinicia todas las réplicas a la vez cuando esta va lenta, convirtiendo una dependencia lenta en una interrupción del servicio.

**Un Pod iniciado a mano desaparece y una corrección manual se deshace.** Un Pod creado de forma independiente permanece en su nodo hasta que termina, se elimina, se expulsa o falla el nodo, y ningún controlador lo recrea; la documentación recomienda un Deployment o un Job incluso para una sola copia. Un cambio realizado con `kubectl edit` vive solo en el clúster, y la siguiente aplicación desde el repositorio restaura el valor anterior, por lo que una corrección de emergencia debe incorporarse a los archivos en cuanto pase la emergencia.

## Lecturas adicionales

- [Visión general de Kubernetes](https://kubernetes.io/docs/concepts/overview/) — la explicación del propio proyecto de qué es Kubernetes, qué ofrece y qué deja fuera.
- [Pods](https://kubernetes.io/docs/concepts/workloads/pods/) — la unidad más pequeña que planifica Kubernetes, su ciclo de vida y por qué rara vez se crean Pods a mano.
- [Deployments](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/) — actualizaciones graduales, reversiones, historial de revisiones y plazo de progreso.
- [Service](https://kubernetes.io/docs/concepts/services-networking/service/) — nombres y direcciones estables ante un conjunto cambiante de Pods.
- [Gestión de recursos para Pods y contenedores](https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/) — peticiones, límites y cómo hace cumplir el núcleo cada uno.
- [Configurar sondas de vitalidad, disponibilidad y arranque](https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-startup-probes/) — las tres sondas y cómo proteger un contenedor de arranque lento.

<https://engineer.company/es/glossary/kubernetes/>
