Cuando empiezas a trabajar con Kubernetes, descubres que existen dos formas de comunicarte con el clúster: el enfoque imperativo y el enfoque declarativo. Aprender ambos te permite movernos con agilidad en pruebas rápidas y, al mismo tiempo, mantener entornos productivos confiables y versionables.

¿Qué es el enfoque imperativo en Kubernetes?

El enfoque imperativo consiste en darle a Kubernetes una instrucción clara, concisa y directa para que ejecute una acción puntual sobre un recurso.

Un ejemplo típico es crear un pod con una sola línea en la terminal usando kubectl. Cuando ejecutas kubectl run my-pod --image=nginx, el clúster recibe la orden y crea el pod inmediatamente, sin más detalles que el nombre y la imagen del contenedor.

¿Cómo crear, listar y eliminar un pod de forma imperativa?

El flujo imperativo se entiende mejor con tres comandos básicos que conviene memorizar.

• kubectl run my-pod --image=nginx crea el pod usando la imagen de nginx.
• kubectl get pods lista los pods activos y muestra estado, reinicios y tiempo de ejecución.
• kubectl delete pod my-pod elimina el pod indicando explícitamente el tipo de recurso.

Este flujo es ideal para debuggear o validar el comportamiento de un pod específico en cuestión de segundos.

¿Cuándo conviene usar el enfoque imperativo? Cuando necesitas hacer pruebas efímeras, depurar un recurso o validar rápidamente que un objeto se comporta como esperas dentro del clúster.

¿Qué es el enfoque declarativo y cómo se usa con archivos YAML?

El enfoque declarativo no le dice a Kubernetes qué hacer paso a paso, sino que le describe el estado deseado de la aplicación a través de un archivo YAML. Kubernetes se encarga de interpretar ese archivo y de llevar el clúster a ese estado.

Un archivo my-pod.yaml típico incluye tres bloques: el tipo de objeto (en este caso Pod), la metadata con el nombre del recurso y la especificación de los contenedores con su imagen, por ejemplo nginx.

¿Cómo aplicar y eliminar recursos con kubectl apply?

Para llevar a la práctica el archivo YAML, basta con dos comandos que reemplazan al flujo imperativo.

• kubectl apply -f my-pod.yaml crea el recurso descrito en el archivo. La bandera -f apunta al archivo o a la carpeta donde están los manifiestos.
• kubectl delete -f my-pod.yaml elimina el recurso sin que tengas que especificar su tipo, porque Kubernetes lo lee desde el manifiesto.

Esta diferencia es clave: en imperativo nombras el recurso (delete pod my-pod), mientras que en declarativo el archivo es la fuente de verdad.

¿Qué es un archivo YAML en Kubernetes? Es un manifiesto de texto plano donde describes el estado deseado de tus objetos: tipo, metadata y especificaciones como imagen, réplicas o recursos asignados.

¿Cuál es la diferencia entre imperativo y declarativo en Kubernetes?

Una analogía musical lo deja claro. El enfoque imperativo es como pedirle a un músico: "interpreta Para Elisa de Beethoven". El declarativo, en cambio, es entregarle la partitura completa: la persona que la lea puede traducirla, y Kubernetes interpretará el estado deseado para gestionar todos los elementos hasta lograr el resultado final.

¿Cuáles son las ventajas y desventajas de cada enfoque?

Cada modo tiene un terreno donde brilla y otro donde se queda corto.

• Imperativo: rápido y directo para pruebas concretas, pero difícil de mantener en el tiempo. Si quieres revertir una imagen o agregar réplicas, tendrías que recordar y ejecutar comandos al pie de la letra, lo que se vuelve frágil en producción.
• Declarativo: ideal para entornos productivos porque los YAML se versionan en repositorios como GitHub, se auditan y permiten especificar detalles avanzados como límites de memoria y CPU. Su desventaja es la curva de aprendizaje de la sintaxis YAML.

La buena noticia es que YAML no solo se usa en Kubernetes. También aparece en herramientas como GitHub Actions y Jenkins, así que dominarlo te sirve en todo el entorno DevOps y cloud.

¿Cuándo usar uno u otro en proyectos reales?

La decisión depende del contexto y del ciclo de vida de tu aplicación.

• Usa el imperativo para experimentar, depurar o validar comportamientos puntuales de pods, deployments o HPAs.
• Usa el declarativo cuando necesites desplegar aplicaciones escalables, mantener historial de cambios y trabajar en equipo sobre la misma infraestructura.
• Combina ambos: prototipa rápido en imperativo y traslada la versión final a manifiestos YAML para producción.

Las aplicaciones reales rara vez se reducen a un solo pod. Por eso el siguiente paso natural son los deployments y los replicaSets, objetos que permiten orquestar múltiples pods y combinar estos dos enfoques en escenarios productivos.

¿Probaste a crear un pod con dos contenedores de imágenes distintas usando ambos enfoques? Cuéntame en los comentarios qué diferencias notaste al escribir el comando frente al manifiesto YAML.