Guía de Kubernetes Nivel Avanzado: Arquitectura, Objetos, Redes y Seguridad por Santiago Soñora

“Hola, mundo” en Kubernetes

El 'Hola, mundo' en Kubernetes: desplegar una aplicación simple (ej. Nginx) como un Deployment y exponerla con un Service para que sea accesible.

📋 Copiar

kubectl create deployment nginx-hello --image=nginx
kubectl expose deployment nginx-hello --type=NodePort --port=80

Resultado:

Output

deployment.apps/nginx-hello created
service/nginx-hello exposed

Comandos básicos

Familiarizarse con estos comandos es esencial para interactuar eficientemente con Kubernetes:

Ver los nodos del clúster
📋 Copiar
```
kubectl get nodes
```
Muestra información sobre los nodos (máquinas de trabajo) que componen el clúster, incluyendo su estado, roles y versión.
Listar pods
📋 Copiar
```
kubectl get pods -n nombre-namespace
```
Muestra los pods en el namespace especificado. Si `-n` se omite, muestra los pods en el namespace actual (generalmente `default`).
Listar Deployments
📋 Copiar
```
kubectl get deployments
```
Muestra todos los objetos Deployment en el namespace actual.
Listar Services
📋 Copiar
```
kubectl get services
```
Muestra todos los objetos Service en el namespace actual, incluyendo su tipo y direcciones IP/puertos.
Aplicar un manifiesto YAML
📋 Copiar
```
kubectl apply -f nombre-manifiesto.yaml
```
Crea o actualiza recursos (Pods, Deployments, Services, etc.) definidos en un archivo YAML. Es la forma preferida de gestionar recursos.
Editar un recurso en vivo
📋 Copiar
```
kubectl edit deployment nombre-despliegue
```
Abre la configuración actual de un recurso en tu editor por defecto, permitiéndote modificarla y aplicarla directamente al clúster.
Ver detalles de un recurso
📋 Copiar
```
kubectl describe pod nombre-pod
```
Muestra información detallada sobre el estado, eventos, asignación de nodos y configuración de un recurso específico. Muy útil para depurar.
Eliminar un recurso
📋 Copiar
```
kubectl delete deployment nombre-despliegue
```
Elimina el recurso especificado del clúster. Puedes usar `-f` con un archivo YAML para eliminar múltiples recursos.
Ver logs de un pod
📋 Copiar
```
kubectl logs nombre-pod
```
Muestra los logs de la salida estándar (`stdout`) y de error (`stderr`) del primer contenedor en el pod especificado.
Ver logs de un contenedor específico en un pod
📋 Copiar
```
kubectl logs nombre-pod -c nombre-contenedor
```
Muestra los logs de un contenedor particular dentro de un pod que tiene varios contenedores.
Ejecutar comando dentro de un pod
📋 Copiar
```
kubectl exec -it nombre-pod -- bash
```
Ejecuta un comando (ej: `bash`, `sh`) dentro de un contenedor en ejecución dentro de un pod, permitiendo interactuar con el contenedor.
Revisar estado de un despliegue progresivo (Rolling Update)
📋 Copiar
```
kubectl rollout status deployment/nombre-despliegue
```
Monitorea el progreso de una actualización de despliegue, indicando cuántas réplicas nuevas están disponibles.
Deshacer un despliegue (Rollback)
📋 Copiar
```
kubectl rollout undo deployment/nombre-despliegue
```
Revierte un despliegue a la versión anterior.
Port-forwarding a un pod
📋 Copiar
```
kubectl port-forward service/nombre-servicio 8080:80
```
Mapea un puerto en tu máquina local (8080) al puerto de un servicio o pod (80), permitiendo acceder a la aplicación sin exponerla externamente.
Crear ConfigMap desde archivo
📋 Copiar
```
kubectl create configmap nombre-config --from-file=/ruta/a/config.file
```
Crea un recurso ConfigMap que almacena datos de configuración no sensibles, a menudo montado como archivos o variables de entorno en Pods.
Crear Secret desde literal
📋 Copiar
```
kubectl create secret generic nombre-secret --from-literal=username='admin' --from-literal=password='password123'
```
Crea un recurso Secret para almacenar datos sensibles (credenciales, claves API) de forma base64-encoded (no cifrada por defecto en etcd).

Crear PersistentVolumeClaim (PVC)

📋 Copiar

# Contenido de pvc.yaml:
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-app-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 5Gi

Define y crea una solicitud para obtener almacenamiento persistente (un PersistentVolume) de un tamaño y modo de acceso específicos.

Crear Namespace
📋 Copiar
```
kubectl create namespace nombre-equipo-o-proyecto
```
Crea un nuevo Namespace para dividir los recursos del clúster en grupos lógicos y aislados (para equipos, entornos, aplicaciones).
Cambiar Namespace actual (config)
📋 Copiar
```
kubectl config set-context --current --namespace=nombre-equipo-o-proyecto
```
Configura el namespace por defecto para los comandos `kubectl` en tu contexto actual, evitando tener que usar `-n` repetidamente.

Conceptos Clave

Comprender estos conceptos fundamentales te ayudará a dominar Kubernetes de forma más organizada y eficiente:

Arquitectura de Kubernetes:

Comprender los dos componentes principales: el Control Plane (compuesto por API Server, etcd, Scheduler, Controller Manager) que es el 'cerebro' del clúster y gestiona su estado, y los Nodos (minions) donde se ejecutan los Pods, conteniendo Kubelet, Kube-proxy y un Container Runtime (ej. containerd, cri-o).
Objetos de la API de Kubernetes Detallados:

Profundizar en los recursos que gestionas: Pods (la unidad de despliegue más pequeña, uno o más contenedores compartiendo recursos), ReplicaSets (garantizan un número constante de Pods en ejecución), Deployments (abstracción de nivel superior para gestionar ReplicaSets, permitiendo actualizaciones declarativas y rollbacks), y Services (formas de acceder a un conjunto de Pods, con tipos como ClusterIP, NodePort, LoadBalancer, ExternalName).
Manifiestos YAML y Despliegue Declarativo:

Definir el estado deseado de los recursos en el clúster utilizando archivos YAML. Kubernetes sigue un modelo declarativo: tú describes el estado final, y el clúster trabaja continuamente para alcanzar ese estado. Entender la estructura de los manifiestos (`apiVersion`, `kind`, `metadata`, `spec`, `status`).
Almacenamiento Persistente (PVs, PVCs, StorageClasses):

Cómo gestionar el almacenamiento de datos que debe sobrevivir a la terminación/recreación de Pods. Los Persistent Volumes (PVs) representan el almacenamiento físico subyacente. Los Persistent Volume Claims (PVCs) son solicitudes de almacenamiento por parte de los Pods. Las StorageClasses permiten la provisión dinámica de PVs.
Gestión de Configuración y Secretos (ConfigMaps y Secrets):

Almacenar información de configuración no sensible (ConfigMaps) y sensible (Secrets) de forma centralizada y separada de la imagen del contenedor. Cómo estos objetos se pueden montar como archivos o exponer como variables de entorno dentro de los Pods de forma segura.
Redes en Kubernetes Avanzado (Service Discovery, DNS, Ingress):

Cómo los Pods y Services se descubren entre sí (DNS del clúster). Cómo se enruta el tráfico dentro del clúster. Cómo exponer aplicaciones a la red externa: a través de tipos de Service (NodePort, LoadBalancer) o, para acceso HTTP/S basado en reglas (routing por nombre de host, path), utilizando Ingress y un Ingress Controller.
Estrategias de Despliegue (Rolling Updates, Rollbacks):

Implementar actualizaciones de aplicaciones a nuevas versiones minimizando el tiempo de inactividad. Los Deployments soportan Rolling Updates por defecto (se despliegan nuevas réplicas gradualmente mientras se terminan las viejas). También permiten revertir fácilmente a una versión anterior (`kubectl rollout undo`).
Monitoreo y Logging:

La importancia de la observabilidad. Recopilar métricas del clúster y las aplicaciones (monitoreo) para entender su rendimiento y estado (con herramientas como Prometheus, Grafana). Recopilar, agregar y analizar los logs de los contenedores (logging) para depuración y auditoría (con herramientas como el stack ELK/EFK).
Seguridad en Kubernetes (RBAC y Security Context):

Implementar el control de acceso basado en roles (RBAC) para definir permisos granulares para usuarios y ServiceAccounts (quién puede hacer qué en qué namespace o recurso). Utilizar el Security Context a nivel de Pod y Contenedor para definir ajustes de seguridad de ejecución (ej: usuario/grupo no root, capacidades).
StatefulSets vs Deployments:

Comprender cuándo utilizar StatefulSets en lugar de Deployments. StatefulSets se diseñan para aplicaciones con estado que requieren identidades de red estables, almacenamiento persistente único por réplica y un orden de despliegue/escalado/eliminación garantizado (ej: bases de datos, sistemas de mensajería con clustering). Los Deployments son para aplicaciones 'sin estado'.
DaemonSets y Jobs/CronJobs:

Otros tipos de carga de trabajo. Los DaemonSets aseguran que una copia de un Pod se ejecuta en todos (o un subconjunto) de los Nodos del clúster (ej: agentes de logging, monitoreo). Los Jobs ejecutan tareas que se completan y terminan. Los CronJobs automatizan la ejecución de Jobs en un horario definido.
Helm (Gestor de Paquetes para Kubernetes):

La herramienta estándar para empaquetar, desplegar y gestionar aplicaciones complejas en Kubernetes. Los 'Charts' de Helm son colecciones preconfiguradas de manifiestos YAML que definen una aplicación completa y sus dependencias, simplificando la instalación y actualización.
Troubleshooting (Depuración en Kubernetes):

Dominar el uso de comandos como `kubectl describe <resource>`, `kubectl logs <pod>`, `kubectl exec <pod> -- <command>`, `kubectl events`, y comprender los estados y eventos de los objetos de la API para diagnosticar y resolver problemas de despliegue, ejecución o redes.

Casos de uso

Algunos ejemplos de aplicaciones prácticas donde se utiliza Kubernetes:

Desplegar y gestionar bases de datos distribuidas u otras aplicaciones con estado utilizando StatefulSets:

Implementar y operar aplicaciones que requieren almacenamiento persistente con identidades estables y un orden de operación, aprovechando las características de los StatefulSets.
Gestionar de forma centralizada y segura la configuración y los secretos de las aplicaciones en el clúster:

Utilizar ConfigMaps y Secrets para desacoplar la configuración sensible y no sensible del código y las imágenes, y montarla en los Pods de forma controlada y segura.
Implementar estrategias de despliegue avanzadas (ej: Blue/Green, Canary Releases):

Configurar Deployments, Services y quizás recursos Ingress o herramientas externas para lanzar nuevas versiones de una aplicación a un subconjunto de usuarios o en paralelo con la versión anterior para minimizar el riesgo.
Configurar Ingress para enrutar tráfico externo a múltiples servicios y gestionar certificados SSL/TLS:

Desplegar un Ingress Controller y definir reglas Ingress para exponer múltiples aplicaciones a través de un único punto de entrada, gestionando el routing basado en hostname o path y la terminación SSL.
Implementar un sistema de monitoreo y logging centralizado para toda la infraestructura y las aplicaciones:

Desplegar soluciones de observabilidad (ej: Prometheus + Grafana para métricas, Fluentd/Logstash + Elasticsearch + Kibana para logs) para recopilar, visualizar y alertar sobre el estado del clúster y las aplicaciones.
Implementar control de acceso granular para usuarios y ServiceAccounts (RBAC):

Definir Roles y RoleBindings para otorgar permisos específicos a usuarios, grupos o ServiceAccounts, asegurando que cada entidad solo tenga acceso a los recursos y operaciones necesarios.
Automatizar el despliegue y la gestión del ciclo de vida de aplicaciones complejas utilizando Helm Charts:

Crear o utilizar Charts de Helm para empaquetar aplicaciones con todas sus dependencias y recursos de Kubernetes asociados, simplificando su instalación, configuración y actualización en diferentes entornos.
Ejecutar tareas batch, trabajos programados o tareas de mantenimiento en el clúster:

Utilizar los objetos Job para ejecutar tareas que se completan (ej: migraciones de base de datos) y CronJob para automatizar la ejecución de tareas en un horario (ej: backups).

Consejos para Principiantes

Aquí tienes algunas recomendaciones para facilitar tus inicios en Kubernetes:

Domina `kubectl` (¡Es tu Puerta de Entrada!):

`kubectl` es la herramienta fundamental para interactuar con el clúster. Aprende los comandos esenciales (`get`, `describe`, `apply`, `delete`, `logs`, `exec`), a usar opciones de filtrado y a entender los diferentes formatos de salida. Practica mucho con él.
Entiende Profundamente los Objetos de la API y sus Relaciones:

No te limites a los comandos básicos. Comprende el propósito de cada objeto clave (Pod, ReplicaSet, Deployment, Service, PV, PVC, ConfigMap, Secret) y cómo se relacionan entre sí. Un Deployment gestiona ReplicaSets, que a su vez gestionan Pods, y un Service expone Pods.
Aprende a Escribir y Depurar Manifiestos YAML:

Los manifiestos son la forma de describir el estado deseado. Entiende su estructura básica. Usa `kubectl apply -f` para aplicarlos y `kubectl describe` y `kubectl logs` para ver si algo salió mal después de aplicarlos.
Practica la Depuración (Troubleshooting):

Los problemas ocurrirán. Acostúmbrate a usar `kubectl describe` para ver el estado detallado, eventos y mensajes de error de un recurso. Usa `kubectl logs` para ver la salida de los contenedores y `kubectl exec` para ejecutar comandos dentro de ellos para diagnosticar problemas.
Comprende los Conceptos Clave de Redes en Kubernetes:

Entiende cómo funciona el descubrimiento de servicios basado en DNS, cómo los Pods se comunican, y cómo exponer tus aplicaciones utilizando los tipos de Service (ClusterIP, NodePort, LoadBalancer) e Ingress para acceso HTTP/S.
Implementa Almacenamiento Persistente para Aplicaciones con Estado:

Si tu aplicación necesita almacenar datos (bases de datos, caches con estado, sistemas de archivos), usa Persistent Volumes y Persistent Volume Claims para asegurar que los datos sobrevivan al ciclo de vida de los Pods. Aprende sobre StorageClasses.
Sé Consciente de la Seguridad (RBAC, Secrets):

Implementa RBAC para controlar quién puede hacer qué en tu clúster. Utiliza objetos Secret para almacenar credenciales y datos sensibles, y aprende a inyectarlos de forma segura en tus Pods (como variables de entorno o archivos montados).
Empieza con Clusters Locales (Minikube, kind, Docker Desktop):

Utiliza herramientas como Minikube, kind o la integración de Kubernetes en Docker Desktop para tener un clúster local para aprender y experimentar sin necesidad de recursos en la nube.
Explora Herramientas de Empaquetado como Helm:

Una vez que te sientas cómodo con los manifiestos básicos, explora Helm. Te permitirá empaquetar y desplegar aplicaciones complejas con todas sus dependencias de forma reusable y configurable.
Considera los Fundamentos de Monitoreo y Logging:

Piensa en cómo vas a observar el estado y rendimiento de tu clúster y aplicaciones. Familiarízate con los conceptos de la suite Prometheus/Grafana para métricas y el stack ELK/EFK para logging.

Herramientas relacionadas

Si te interesa Kubernetes, también podrías explorar estas herramientas:

Recursos útiles

Amplía tus conocimientos con estos enlaces y materiales: