Por qué practicar Kubernetes en tu propio equipo
Kubernetes se ha convertido en el estándar para ejecutar contenedores en producción, pero su fama de complejo asusta a mucha gente antes de escribir la primera línea. La buena noticia es que no necesitas una nube ni un clúster de varias máquinas para aprenderlo. Con un clúster local de un solo nodo puedes experimentar con los mismos objetos, los mismos manifiestos y las mismas herramientas que usarás después en un entorno real.
En esta guía vas a desplegar paso a paso una aplicación de gestión de tareas formada por una API y una base de datos PostgreSQL. Empezarás con comandos imperativos para entender qué ocurre por debajo, pasarás a manifiestos declarativos, añadirás réplicas, configuración, secretos y almacenamiento persistente, y terminarás publicando todo detrás de un único punto de entrada HTTP. Por el camino verás cómo diagnosticar los fallos más habituales.
Se asume que ya sabes construir y ejecutar imágenes. Si necesitas repasar ese punto, puedes revisar este recorrido práctico para construir y ejecutar tu primera app con Docker antes de continuar. Conviene también tener claro por qué se usan contenedores y no máquinas virtuales; si dudas, esta comparativa entre VM y contenedores con Docker y KVM te aclara las diferencias.
Requisitos y versiones que conviene conocer
Para seguir los ejemplos necesitas tres piezas: un motor de contenedores, un clúster local y la herramienta de línea de comandos para hablar con el clúster.
El motor de contenedores será Docker. La rama estable actual de Docker Engine es la 29, así que cualquier versión 29.x sirve. Minikube se encarga de levantar un clúster de un nodo dentro de un contenedor o una máquina virtual; instala su última versión estable desde los paquetes oficiales de tu sistema. Por último, kubectl es el cliente de Kubernetes y debe estar dentro de un margen de una versión menor respecto al clúster. La rama estable de Kubernetes más reciente es la 1.37, y Minikube arranca por defecto una versión estable compatible, de modo que no tendrás que elegirla a mano.
Comprueba que todo está instalado con estos comandos.
docker --version
minikube version
kubectl version --client
Para crear el clúster, indica que use Docker como controlador. Es la opción más cómoda en Linux, macOS y Windows.
minikube start --driver=docker
La salida confirma que el nodo está listo.
😄 minikube v1.x en Linux
✨ Using the docker driver based on user configuration
🏄 Done! kubectl is now configured to use "minikube" cluster
Verifica que kubectl apunta al clúster correcto y que el nodo está en estado Ready.
kubectl cluster-info
kubectl get nodes
NAME STATUS ROLES AGE VERSION
minikube Ready control-plane 1m v1.37.0
Cuando quieras pausar el trabajo usa minikube stop, y si quieres empezar de cero, minikube delete elimina el clúster completo. Tener esa opción a mano es una de las grandes ventajas de aprender en local: equivocarse no cuesta nada.
Cómo está organizado un clúster por dentro
Antes de lanzar objetos conviene tener un mapa mental. Un clúster se divide en el plano de control y los nodos de trabajo. En Minikube ambos conviven en la misma máquina, pero los componentes son los mismos que en un clúster grande.
El plano de control contiene el servidor de la API, que es la puerta de entrada de cualquier petición, tanto de kubectl como de los propios componentes internos. Junto a él está etcd, la base de datos clave-valor donde se guarda el estado deseado del clúster. El planificador decide en qué nodo se ejecuta cada pod nuevo según recursos y restricciones, y el gestor de controladores ejecuta bucles que comparan el estado real con el deseado y corrigen las diferencias.
Cada nodo ejecuta el kubelet, un agente que recibe las órdenes del plano de control y se asegura de que los contenedores de sus pods estén vivos. También ejecuta kube-proxy, que implementa las reglas de red para los servicios, y un motor de contenedores compatible con la interfaz de ejecución de Kubernetes, como containerd.
La idea central es el modelo declarativo: tú describes cómo quieres que sea el sistema y los controladores trabajan sin parar para que la realidad coincida con esa descripción. Si un contenedor se cae, se vuelve a crear; si pides tres réplicas y hay dos, se lanza una más. Esta lógica explica casi todo el comportamiento que verás a continuación.
Tu primer pod con comandos imperativos
El pod es la unidad mínima desplegable. Contiene uno o varios contenedores que comparten red y almacenamiento. Lo habitual es un único contenedor por pod, y los pods adicionales se reservan para casos de apoyo, como un proceso que recoge logs.
Para ver el mecanismo sin ceremonias, lanza un servidor web sencillo con un comando imperativo.
kubectl run prueba-web --image=nginx:alpine --port=80
pod/prueba-web created
Consulta el estado hasta que aparezca como Running.
kubectl get pods
NAME READY STATUS RESTARTS AGE
prueba-web 1/1 Running 0 12s
El pod tiene una dirección IP interna, pero esa dirección cambia cada vez que el pod se recrea. Por eso existe el objeto Service, que ofrece un nombre y una IP estables delante de un conjunto de pods. Existen cuatro tipos principales: ClusterIP expone el servicio solo dentro del clúster, NodePort abre un puerto en cada nodo, LoadBalancer pide un balanceador externo al proveedor y ExternalName devuelve un alias DNS.
Expón el pod como NodePort y pide a Minikube que abra la URL en tu navegador.
kubectl expose pod prueba-web --type=NodePort --port=80
minikube service prueba-web
Lo que has hecho aquí es útil para explorar, pero tiene un límite claro: si borras el pod, desaparece para siempre, y nadie lo vuelve a crear. Limpia antes de seguir.
kubectl delete service prueba-web
kubectl delete pod prueba-web
Los comandos imperativos están bien para pruebas puntuales. En cuanto el sistema tenga más de una pieza, lo correcto es describirlo en archivos y dejar que Kubernetes los aplique.
Pasar a manifiestos declarativos en YAML
Un manifiesto es un archivo YAML con cuatro campos de primer nivel. El campo apiVersion indica el grupo y la versión de la API del objeto, kind el tipo de recurso, metadata el nombre y las etiquetas, y spec el estado deseado. Los pods, servicios, ConfigMaps, Secrets y volúmenes persistentes usan la versión v1; los Deployment y StatefulSet usan apps/v1; y los Ingress usan networking.k8s.io/v1.
Organiza el proyecto en un directorio con un archivo por objeto. Esta estructura facilita aplicar todo de golpe.
tareas-k8s/
├── api-deployment.yaml
├── api-service.yaml
├── base-datos-deployment.yaml
├── base-datos-service.yaml
├── base-datos-pvc.yaml
├── configuracion.yaml
├── credenciales.yaml
└── ingress.yaml
Para entender cómo se relacionan los objetos, empieza con un pod declarativo y su servicio. Las etiquetas son el pegamento: el servicio selecciona los pods cuyas etiquetas coincidan con su selector.
apiVersion: v1
kind: Pod
metadata:
name: tareas-api
labels:
app: tareas
capa: api
spec:
containers:
- name: api
image: ghcr.io/ejemplo/tareas-api:1.0
ports:
- containerPort: 3000
apiVersion: v1
kind: Service
metadata:
name: tareas-api
spec:
type: ClusterIP
selector:
app: tareas
capa: api
ports:
- port: 80
targetPort: 3000
La imagen de ejemplo representa una API que tú mismo habrías construido y publicado en un registro; sustitúyela por la tuya. Aplica los archivos con un solo comando.
kubectl apply -f api-service.yaml
El comando apply es idempotente: si el objeto no existe lo crea y, si existe, calcula las diferencias y las aplica. Puedes ejecutarlo tantas veces como quieras. Cuando tengas un directorio completo, basta con kubectl apply -f tareas-k8s/ para procesar todos los archivos.
Para inspeccionar lo que has creado, combina get con la opción -o wide y usa describe cuando algo no cuadre.
kubectl get pods,services -o wide
kubectl describe pod tareas-api
Si prefieres una vista gráfica, Minikube incluye un panel web que se abre con minikube dashboard. Es muy útil para ver la relación entre objetos, aunque con el tiempo preferirás la terminal.
Deployments: réplicas y actualizaciones sin cortes
Gestionar pods sueltos es una mala práctica. Si el nodo falla o el proceso muere, nadie los repone, y tampoco puedes actualizarlos de forma ordenada. El recurso adecuado para aplicaciones sin estado es el Deployment, que crea un ReplicaSet y este a su vez mantiene el número de pods deseado.
Reescribe la API como Deployment con tres réplicas.
apiVersion: apps/v1
kind: Deployment
metadata:
name: tareas-api
labels:
app: tareas
spec:
replicas: 3
selector:
matchLabels:
app: tareas
capa: api
template:
metadata:
labels:
app: tareas
capa: api
spec:
containers:
- name: api
image: ghcr.io/ejemplo/tareas-api:1.0
ports:
- containerPort: 3000
resources:
requests:
cpu: "100m"
memory: "128Mi"
limits:
memory: "256Mi"
Presta atención a que el selector del Deployment debe coincidir con las etiquetas de la plantilla del pod. Si no coinciden, Kubernetes rechaza el manifiesto. El bloque de recursos declara cuánta CPU y memoria necesita cada réplica; el planificador lo usa para decidir el nodo, y el límite de memoria evita que un proceso desbocado afecte a sus vecinos.
Borra el pod suelto del apartado anterior y aplica el Deployment.
kubectl delete pod tareas-api
kubectl apply -f api-deployment.yaml
kubectl get deployments
kubectl get pods
NAME READY UP-TO-DATE AVAILABLE AGE
tareas-api 3/3 3 3 25s
Prueba la autorrecuperación borrando uno de los pods. En pocos segundos aparecerá otro con un nombre distinto, porque el controlador detecta que faltan réplicas.
Para actualizar la aplicación cambia la etiqueta de la imagen y vuelve a aplicar. La estrategia por defecto es de actualización progresiva: se crean pods nuevos mientras se retiran los antiguos, de manera que el servicio sigue respondiendo. Puedes seguir el avance y deshacer el cambio si algo sale mal.
kubectl set image deployment/tareas-api api=ghcr.io/ejemplo/tareas-api:1.1
kubectl rollout status deployment/tareas-api
kubectl rollout history deployment/tareas-api
kubectl rollout undo deployment/tareas-api
Aunque set image es cómodo, en un proyecto real es mejor editar el manifiesto y aplicarlo, porque así el repositorio siempre refleja el estado del clúster. El escalado funciona igual, y puedes modificarlo temporalmente con kubectl scale deployment tareas-api --replicas=5.
Sondas de salud para que Kubernetes sepa si tu app responde
Un contenedor en ejecución no es lo mismo que una aplicación lista para atender tráfico. Si la API tarda diez segundos en conectar con la base de datos, durante ese tiempo el servicio enviaría peticiones a una réplica que todavía no puede responder. Para evitarlo existen las sondas.
La sonda de disponibilidad decide si el pod entra en el reparto de tráfico del servicio. La sonda de vida decide si el contenedor debe reiniciarse porque se ha quedado bloqueado. Se añaden dentro del contenedor del Deployment.
readinessProbe:
httpGet:
path: /salud
port: 3000
initialDelaySeconds: 5
periodSeconds: 10
livenessProbe:
httpGet:
path: /salud
port: 3000
initialDelaySeconds: 15
periodSeconds: 20
Con estas sondas, una actualización progresiva solo retira las réplicas antiguas cuando las nuevas responden correctamente en la ruta indicada. Es una de las mejores inversiones de tiempo que puedes hacer al preparar una aplicación para Kubernetes, y suele quedar olvidada en los tutoriales introductorios.
Configuración con ConfigMaps y secretos con Secrets
Las imágenes deben ser iguales en todos los entornos; lo que cambia es la configuración. Kubernetes separa ambas cosas con dos objetos. El ConfigMap guarda datos no sensibles como nombres de host, niveles de log o banderas de funcionalidades. El Secret guarda credenciales y tokens.
Crea el ConfigMap con los datos de conexión de la API.
apiVersion: v1
kind: ConfigMap
metadata:
name: tareas-config
data:
DB_HOST: base-datos
DB_PORT: "5432"
DB_NAME: tareas
NIVEL_LOG: info
Y el Secret con las credenciales. Usa el campo stringData para escribir los valores en texto plano y que Kubernetes los codifique al guardarlos.
apiVersion: v1
kind: Secret
metadata:
name: tareas-credenciales
type: Opaque
stringData:
DB_USER: tareas_app
DB_PASSWORD: cambia-esta-clave
Es importante entender que un Secret está codificado en base64, no cifrado. Cualquiera con permiso de lectura sobre él puede recuperar el valor. Para proteger de verdad los datos sensibles se activa el cifrado en reposo de etcd, se restringe el acceso con RBAC y, en producción, se suele integrar un gestor externo de secretos. Además, nunca subas a un repositorio un manifiesto con contraseñas reales.
Para inyectar ambos objetos en el contenedor de la API, usa envFrom, que importa todas las claves como variables de entorno, o valueFrom para escoger claves concretas.
containers:
- name: api
image: ghcr.io/ejemplo/tareas-api:1.0
envFrom:
- configMapRef:
name: tareas-config
env:
- name: DB_USER
valueFrom:
secretKeyRef:
name: tareas-credenciales
key: DB_USER
- name: DB_PASSWORD
valueFrom:
secretKeyRef:
name: tareas-credenciales
key: DB_PASSWORD
Un detalle práctico: las variables de entorno se leen al arrancar el contenedor. Si modificas el ConfigMap, los pods existentes no se enteran hasta que se reinicien. Se resuelve con kubectl rollout restart deployment/tareas-api.
Almacenamiento persistente para la base de datos
Los contenedores son efímeros: al recrearse pierden todo lo escrito en su sistema de archivos. Para una base de datos eso es inaceptable, así que hay que montar un volumen que sobreviva a los pods. Kubernetes lo resuelve con tres conceptos.
Un PersistentVolume representa un trozo de almacenamiento del clúster. Un PersistentVolumeClaim es la solicitud de un usuario que pide cierta capacidad y un modo de acceso. Una StorageClass describe cómo se aprovisiona dinámicamente ese almacenamiento. En Minikube existe una clase por defecto que crea el volumen automáticamente cuando alguien presenta una solicitud, de modo que normalmente solo escribes el PersistentVolumeClaim.
Los modos de acceso más comunes son ReadWriteOnce, que permite montar el volumen en lectura y escritura desde un solo nodo, ReadOnlyMany y ReadWriteMany.
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: base-datos-pvc
spec:
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 2Gi
Comprueba que la solicitud se ha enlazado a un volumen.
kubectl apply -f base-datos-pvc.yaml
kubectl get pvc
kubectl get pv
NAME STATUS VOLUME CAPACITY ACCESS MODES STORAGECLASS
base-datos-pvc Bound pvc-5b1c0f0e-0000-0000-0000-000000000000 2Gi RWO standard
Ahora define el Deployment de PostgreSQL. Con una sola réplica es suficiente para aprender. Observa que se monta el volumen en el directorio de datos y que se usa un subdirectorio, porque la raíz de un volumen recién creado puede contener una carpeta que PostgreSQL considera un directorio no vacío y se niega a inicializar.
apiVersion: apps/v1
kind: Deployment
metadata:
name: base-datos
labels:
app: tareas
spec:
replicas: 1
strategy:
type: Recreate
selector:
matchLabels:
app: tareas
capa: datos
template:
metadata:
labels:
app: tareas
capa: datos
spec:
containers:
- name: postgres
image: postgres:17-alpine
ports:
- containerPort: 5432
env:
- name: POSTGRES_DB
valueFrom:
configMapKeyRef:
name: tareas-config
key: DB_NAME
- name: POSTGRES_USER
valueFrom:
secretKeyRef:
name: tareas-credenciales
key: DB_USER
- name: POSTGRES_PASSWORD
valueFrom:
secretKeyRef:
name: tareas-credenciales
key: DB_PASSWORD
volumeMounts:
- name: datos
mountPath: /var/lib/postgresql/data
subPath: pgdata
volumes:
- name: datos
persistentVolumeClaim:
claimName: base-datos-pvc
La estrategia Recreate es deliberada. Con la actualización progresiva, durante unos instantes convivirían dos pods apuntando al mismo volumen de acceso único, algo que provoca bloqueos o corrupción. Recreate detiene el pod viejo antes de lanzar el nuevo.
Un aviso de diseño: para bases de datos con varias réplicas o identidad estable se utiliza un StatefulSet, que asigna nombres ordenados y un volumen propio a cada pod. Para este ejercicio de una sola instancia, el Deployment es suficiente, pero en producción deberías valorar un operador de base de datos o un servicio gestionado.
Comunicación interna mediante nombres de servicio
La API necesita encontrar la base de datos, y no debe depender de IPs que cambian. Kubernetes incluye un DNS interno: cada Service recibe un nombre resoluble dentro del clúster. Crea un servicio ClusterIP para PostgreSQL con el mismo nombre que has puesto en DB_HOST.
apiVersion: v1
kind: Service
metadata:
name: base-datos
spec:
type: ClusterIP
selector:
app: tareas
capa: datos
ports:
- port: 5432
targetPort: 5432
Desde cualquier pod del mismo espacio de nombres, el nombre base-datos resuelve a la IP del servicio. Desde otro espacio de nombres se usa la forma completa, por ejemplo base-datos.default.svc.cluster.local. Que la base de datos use ClusterIP es una decisión de seguridad: nada fuera del clúster puede alcanzarla directamente.
Aplica todo el directorio y observa cómo se levantan las piezas.
kubectl apply -f tareas-k8s/
kubectl get all
Si quieres comprobar la conectividad sin exponer nada, puedes abrir un túnel temporal desde tu equipo hacia el servicio de la API.
kubectl port-forward service/tareas-api 8080:80
Mientras ese comando esté activo, la API responde en el puerto 8080 de tu máquina. Es una herramienta de depuración excelente, y no sustituye a una exposición real.
Un único punto de entrada con Ingress
Hasta ahora, para exponer algo has usado NodePort. Si tuvieras varios servicios, necesitarías un balanceador o un puerto por cada uno, lo cual es caro y difícil de gestionar. Un Ingress resuelve este problema: define reglas de enrutado HTTP, por ruta o por nombre de host, y un controlador de Ingress las aplica con un único balanceador.
Un detalle imprescindible: el objeto Ingress por sí solo no hace nada. Necesita un controlador instalado en el clúster. En Minikube se activa con un complemento basado en NGINX.
minikube addons enable ingress
kubectl get pods -n ingress-nginx
Conviene saber que el proyecto del controlador NGINX comunitario anunció su retirada progresiva y que la evolución natural del ecosistema es la API Gateway, un conjunto de recursos más expresivo. Para aprender los conceptos de enrutado, el Ingress clásico sigue siendo perfectamente válido y es lo que verás en muchos clústeres existentes.
Define una regla que envíe las peticiones de /api al servicio de la API.
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: tareas-ingress
annotations:
nginx.ingress.kubernetes.io/rewrite-target: /$2
spec:
ingressClassName: nginx
rules:
- host: tareas.local
http:
paths:
- path: /api(/|$)(.*)
pathType: ImplementationSpecific
backend:
service:
name: tareas-api
port:
number: 80
La anotación de reescritura elimina el prefijo /api antes de entregar la petición a la API, que probablemente espera rutas como /tareas. Fíjate también en el campo ingressClassName, que sustituye a la antigua anotación de clase y es la forma recomendada hoy.
Aplica el manifiesto y averigua la IP del clúster.
kubectl apply -f ingress.yaml
kubectl get ingress
minikube ip
Para que el nombre tareas.local funcione, añade a tu archivo de hosts la IP que devuelve Minikube. Con el controlador Docker en macOS y Windows la red del clúster no es accesible directamente; en ese caso ejecuta minikube tunnel en otra terminal y usa la dirección local. Después prueba con curl.
curl http://tareas.local/api/tareas
Etiquetas, espacios de nombres y orden en el clúster
A medida que crecen los proyectos, se hace necesario organizar. Los espacios de nombres dividen un clúster en áreas lógicas con sus propios nombres, cuotas y permisos. Un patrón sencillo es separar entornos o equipos.
kubectl create namespace desarrollo
kubectl apply -f tareas-k8s/ -n desarrollo
kubectl get pods -n desarrollo
Para no escribir el espacio de nombres en cada comando, puedes fijarlo en tu contexto actual.
kubectl config set-context --current --namespace=desarrollo
Las etiquetas también permiten filtrar. Con kubectl get pods -l capa=api obtienes solo los pods de la API, y puedes combinarlo con delete o logs. Mantener una convención coherente de etiquetas, como la aplicación, el componente y la versión, ahorra mucho tiempo cuando el clúster tiene decenas de objetos.
Diagnóstico: qué mirar cuando algo falla
Tarde o temprano un pod no arrancará. La clave es seguir un orden de investigación fijo en lugar de adivinar. El primer paso es mirar el estado general.
kubectl get pods
NAME READY STATUS RESTARTS AGE
tareas-api-6d8f7c9b5-abcde 0/1 CrashLoopBackOff 4 (30s ago) 2m
base-datos-7c4d9f6b8-xyz12 0/1 Pending 0 2m
Cada estado cuenta una historia distinta. Pending indica que el planificador no ha podido asignar el pod, normalmente por falta de recursos o porque el volumen no se ha enlazado. ImagePullBackOff o ErrImagePull señalan que el nodo no puede descargar la imagen: nombre incorrecto, etiqueta inexistente o registro privado sin credenciales. CrashLoopBackOff significa que el contenedor arranca y termina con error una y otra vez.
El segundo paso es describe, cuya sección final de eventos suele dar la causa exacta.
kubectl describe pod base-datos-7c4d9f6b8-xyz12
Events:
Warning FailedScheduling default-scheduler 0/1 nodes are available: pod has unbound immediate PersistentVolumeClaims.
El tercer paso son los logs del contenedor. Si el pod se ha reiniciado, la opción --previous muestra la salida de la ejecución anterior, que es justo la que contiene el error.
kubectl logs tareas-api-6d8f7c9b5-abcde
kubectl logs tareas-api-6d8f7c9b5-abcde --previous
kubectl logs deployment/tareas-api --all-containers=true
Cuando el problema no es de arranque sino de red, entra en un pod y prueba la conectividad desde dentro.
kubectl exec -it deployment/tareas-api -- sh
kubectl get endpoints tareas-api
El comando de endpoints es especialmente revelador: si un servicio no tiene direcciones asociadas, casi seguro que su selector no coincide con las etiquetas de los pods, o que ninguno ha superado la sonda de disponibilidad. De hecho, la discrepancia entre selector y etiquetas es el error de red más frecuente en Kubernetes.
Errores frecuentes y buenas prácticas
Hay un puñado de equivocaciones que casi todos cometen al empezar. Conocerlas de antemano te ahorra horas.
La primera es usar la etiqueta latest en las imágenes. Con ella no sabes qué versión se está ejecutando, y los despliegues dejan de ser reproducibles. Usa siempre etiquetas con versión concreta, e incluso el resumen digest de la imagen en entornos críticos.
La segunda es olvidar los límites de recursos. Sin peticiones ni límites, un pod puede consumir todo el nodo y provocar expulsiones en cadena. Define al menos las peticiones de CPU y memoria, y un límite de memoria razonable.
La tercera es ejecutar contenedores como administrador. Añade un contexto de seguridad que obligue a usar un usuario sin privilegios y bloquee la escalada de permisos.
securityContext:
runAsNonRoot: true
runAsUser: 10001
containers:
- name: api
image: ghcr.io/ejemplo/tareas-api:1.0
securityContext:
allowPrivilegeEscalation: false
readOnlyRootFilesystem: true
La cuarta es mezclar métodos. Si creas un objeto con comandos imperativos y luego lo modificas con apply, acabarás con un estado difícil de razonar. Elige un enfoque declarativo y mantén los manifiestos en un repositorio de control de versiones. Es la base de las prácticas conocidas como GitOps, donde el repositorio es la fuente de verdad y una herramienta sincroniza el clúster con él.
La quinta es confiar en que un clúster local equivale a producción. Minikube no reproduce la alta disponibilidad, los balanceadores reales ni las políticas de red de un entorno gestionado. Es un excelente laboratorio, pero antes de salir a producción debes probar en un entorno similar.
Por último, antes de aplicar cambios grandes, valida con una ejecución en seco. Es una forma barata de detectar errores de sintaxis y de esquema.
kubectl apply -f tareas-k8s/ --dry-run=server
kubectl diff -f tareas-k8s/
El comando diff muestra exactamente qué cambiaría en el clúster, de manera parecida a como lo haría un control de versiones con tu código.
Alternativas a Minikube para clústeres locales
Minikube no es la única opción, y conviene saber en qué se diferencian las demás. Kind ejecuta cada nodo como un contenedor Docker y arranca muy rápido, por lo que es muy popular en integración continua. K3s es una distribución ligera de Kubernetes pensada para equipos modestos y dispositivos de borde, y también se usa en servidores pequeños. Docker Desktop incluye un clúster de un nodo activable con un interruptor, cómodo si ya lo usas a diario.
Minikube destaca por sus complementos integrados, como el Ingress, el panel web o las métricas, y por soportar varios controladores y la creación de varios nodos. Si quieres profundizar más allá de un ejemplo, un itinerario estructurado ayuda a consolidar conceptos; por ejemplo, este curso gratuito y práctico para aprender Docker y Kubernetes propone ejercicios graduales para ir más lejos.
Si prefieres un libro de referencia para tener a mano durante el aprendizaje, Kubernetes in Action, Second Edition cubre en detalle los objetos y la arquitectura que aquí solo hemos recorrido de forma práctica.
Limpieza y siguientes pasos
Cuando termines, elimina los recursos de la aplicación con el mismo directorio que usaste para crearlos. Así te aseguras de no dejar nada huérfano.
kubectl delete -f tareas-k8s/
kubectl get all
Ten en cuenta que los volúmenes dinámicos se eliminan según la política de reclamación de su clase de almacenamiento; revisa con kubectl get pv que no quede nada que no esperabas. Si quieres liberar recursos de tu equipo, detén el clúster con minikube stop o bórralo con minikube delete.
Con la base que has construido, estos son los temas lógicos para continuar: escalado automático con el recurso HorizontalPodAutoscaler y el servidor de métricas, políticas de red para restringir qué pods pueden hablar entre sí, empaquetado con Helm o Kustomize para reutilizar manifiestos entre entornos, y observabilidad con Prometheus y Grafana. Cada uno de ellos se apoya en los objetos que ya conoces.
Conclusiones
Has recorrido el ciclo completo de una aplicación en Kubernetes: un clúster local con Minikube, pods y servicios imperativos para entender los fundamentos, manifiestos declarativos para describir el sistema, Deployments con réplicas y actualizaciones progresivas, configuración separada con ConfigMaps y Secrets, almacenamiento persistente para la base de datos y un Ingress como puerta de entrada única.
Lo más valioso no son los comandos concretos, sino el modelo mental: describes el estado deseado y los controladores lo mantienen. Cuando algo falla, sigues siempre el mismo orden, estado, eventos, logs y red, y las causas aparecen con rapidez. Las sondas de salud, los límites de recursos y los contextos de seguridad convierten un ejemplo de laboratorio en algo cercano a un despliegue serio.
El siguiente paso es repetir el ejercicio con tu propia aplicación, guardar los manifiestos en un repositorio y probar variaciones: otra estrategia de actualización, un segundo espacio de nombres, una regla de Ingress distinta. La práctica deliberada en un clúster desechable es la forma más rápida de ganar confianza antes de tocar producción.
