☸️ Kubernetes Cheatsheet Completo ☸️

Kubernetes (K8s) es una plataforma portable y extensible de código abierto para gestionar cargas de trabajo y servicios en contenedores. Facilita la configuración declarativa y la automatización.

---

1. 🌟 Conceptos Clave

• Clúster (Cluster): Un conjunto de nodos de trabajo (worker machines) que ejecutan aplicaciones en contenedores.
• Nodo (Node): Una máquina virtual o física en el clúster. Contiene servicios para ejecutar Pods.
• Pod: La unidad de computación más pequeña y básica que puedes desplegar en Kubernetes. Contiene uno o más contenedores (que comparten almacenamiento, red y recursos), y la especificación para cómo ejecutarlos.
• Control Plane (Plano de Control): El cerebro del clúster. Gestiona los nodos de trabajo y los Pods en el clúster.
  • kube-apiserver: Expone la API de Kubernetes.
  • etcd: Almacén de clave-valor consistente y de alta disponibilidad para todos los datos del cl clúster.
  • kube-scheduler: Asigna Pods sin nodo a nodos basándose en recursos disponibles.
  • kube-controller-manager: Ejecuta controladores de alto nivel (Deployment, ReplicaSet, etc.).
  • cloud-controller-manager: Integra el clúster con APIs de proveedores de nube (opcional).
• Componentes del Nodo de Trabajo:
  • kubelet: Un agente que se ejecuta en cada nodo, asegura que los contenedores en los Pods se estén ejecutando y en un estado saludable.
  • kube-proxy: Un proxy de red que mantiene reglas de red en los nodos, permitiendo la comunicación de red a tus Pods.
  • Container Runtime (Tiempo de ejecución de contenedores): Software para ejecutar contenedores (ej. containerd, CRI-O, Docker).
• kubectl: La herramienta de línea de comandos para interactuar con el clúster de Kubernetes.
• Objetos de Kubernetes: Entidades persistentes en el clúster que representan el estado deseado de tu clúster (Pods, Deployments, Services, ConfigMaps, Secrets, etc.).

---

2. 🛠️ Configuración Inicial

1. Instalar kubectl: Sigue la guía oficial para tu sistema operativo.
2. Configurar Acceso al Clúster: kubectl usa un archivo de configuración (~/.kube/config) para conectarse a los clústeres.
   • Para clústeres locales (ej. Minikube, Docker Desktop Kubernetes): Generalmente se configura automáticamente.
   • Para clústeres en la nube (GKE, EKS, AKS): Usa las herramientas de la nube para generar el archivo de configuración.
3. Verificar Conexión al Clúster:

   kubectl cluster-info
   kubectl get nodes # Lista los nodos en el clúster

---

3. 📄 Objetos de Kubernetes (YAML)

Kubernetes se gestiona declarativamente usando archivos YAML (o JSON).

3.1. Estructura Básica de un Objeto K8s

apiVersion: v1 # La versión de la API de Kubernetes (ej. v1, apps/v1, networking.k8s.io/v1)
kind: Pod    # El tipo de objeto que estamos creando
metadata:    # Metadatos sobre el objeto
  name: my-pod       # Nombre único del objeto
  labels:            # Etiquetas clave-valor para organizar y seleccionar objetos
    app: my-app
    tier: frontend
spec:        # La especificación deseada para el objeto
  # ... contenido específico del tipo de objeto (ej. contenedores para un Pod)

3.2. Pod

La unidad más pequeña de despliegue.

# my-pod.yaml
apiVersion: v1
kind: Pod
metadata:
  name: my-nginx-pod
  labels:
    app: web
spec:
  containers: # Lista de contenedores en este Pod
    - name: nginx-container # Nombre del contenedor
      image: nginx:latest   # Imagen Docker a usar
      ports:
        - containerPort: 80 # Puerto que expone el contenedor
      env: # Variables de entorno
        - name: MY_ENV_VAR
          value: "Hello"
      resources: # Límites y solicitudes de recursos
        requests:
          memory: "64Mi"
          cpu: "250m" # 250 milicpu = 0.25 vCPU
        limits:
          memory: "128Mi"
          cpu: "500m"
      livenessProbe: # Comprueba si el contenedor está vivo
        httpGet:
          path: /
          port: 80
        initialDelaySeconds: 5
        periodSeconds: 5
      readinessProbe: # Comprueba si el contenedor está listo para servir tráfico
        httpGet:
          path: /
          port: 80
        initialDelaySeconds: 5
        periodSeconds: 5

3.3. Deployment

Controlador para gestionar réplicas de Pods y actualizaciones.

# my-deployment.yaml
apiVersion: apps/v1 # API para Deployments
kind: Deployment
metadata:
  name: my-web-app-deployment
  labels:
    app: my-web-app
spec:
  replicas: 3 # Número deseado de Pods (réplicas)
  selector:   # Cómo el Deployment encuentra los Pods que gestiona
    matchLabels:
      app: my-web-app # Debe coincidir con los labels del template del Pod
  template:   # Plantilla para crear Pods
    metadata:
      labels:
        app: my-web-app
    spec:
      containers:
        - name: web-container
          image: nginx:1.21.6 # Usa una versión específica de la imagen
          ports:
            - containerPort: 80
  strategy: # Estrategia de actualización (default: RollingUpdate)
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1 # Cuántos Pods se pueden crear por encima de las réplicas deseadas
      maxUnavailable: 1 # Cuántos Pods pueden estar no disponibles durante la actualización

3.4. Service

Abstracción para exponer un conjunto de Pods como un servicio de red.

# my-service.yaml
apiVersion: v1
kind: Service
metadata:
  name: my-web-app-service
spec:
  selector: # Selecciona los Pods a los que enviar tráfico (coincide con labels de Pods)
    app: my-web-app
  ports:
    - protocol: TCP
      port: 80        # Puerto que el Service expone
      targetPort: 80  # Puerto del contenedor al que el Service envía tráfico
      # nodePort: 30080 # Para NodePort, opcional
  type: ClusterIP   # Tipo de Service (default: ClusterIP)
  # Tipos de Service:
  # - ClusterIP: Solo accesible desde el clúster (default).
  # - NodePort: Expone el Service en un puerto estático en cada Nodo. Accesible desde fuera del clúster.
  # - LoadBalancer: Expone el Service externamente usando el balanceador de carga del proveedor de nube.
  # - ExternalName: Mapea el Service a un CNAME.

3.5. ConfigMap / Secret

Para inyectar datos de configuración o secretos en los Pods.

# my-configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: my-app-config
data: # Datos en formato clave-valor
  config_file.properties: | # Multilínea
    key1=value1
    key2=value2
  database_url: "jdbc:postgresql://mydb:5432/myapp"

• Secrets: Son similares a ConfigMaps pero están diseñados para datos sensibles. Sus valores se almacenan base64-encoded.

  # my-secret.yaml
  apiVersion: v1
  kind: Secret
  metadata:
    name: my-app-secret
  type: Opaque # Tipo de secreto (default: Opaque, otros: kubernetes.io/dockerconfigjson, etc.)
  data:
    username: dXNlcm5hbWU= # 'username' base64-encoded
    password: cGFzc3dvcmQ= # 'password' base64-encoded
  

  • Importante: Codificar valores a Base64 no es encriptación; es solo codificación. Los Secrets deben ser protegidos mediante RBAC y, en entornos de producción, con soluciones de gestión de secretos (ej. Vault).

---

4. 🚀 Comandos kubectl Comunes

4.1. Ver Información

• kubectl get <resource-type> [name] [options]: Lista o muestra recursos.
  • kubectl get pods
  • kubectl get deployments
  • kubectl get svc (o services)
  • kubectl get cm (o configmaps)
  • kubectl get secret
  • kubectl get nodes
  • kubectl get all (lista recursos comunes)
  • kubectl get pods -o wide (más detalles, ej. IP del nodo, IP del Pod)
  • kubectl get pods -o yaml (muestra la salida en formato YAML)
  • kubectl get pod my-nginx-pod
• kubectl describe <resource-type> <name>: Muestra información detallada sobre un recurso.
  • kubectl describe pod my-nginx-pod
  • kubectl describe deployment my-web-app-deployment
• kubectl logs <pod-name> [-c <container-name>] [-f]: Muestra los logs de un Pod (o contenedor específico).
  • -f / --follow: Sigue los logs en tiempo real.
  • kubectl logs my-nginx-pod -c nginx-container -f
• kubectl exec -it <pod-name> [-c <container-name>] -- <command>: Ejecuta un comando en un contenedor de un Pod.
  • kubectl exec -it my-nginx-pod -- bash (abre un shell en el Pod)
  • kubectl exec -it my-nginx-pod -c my-other-container -- ls /app

4.2. Crear, Aplicar, Actualizar y Eliminar

• kubectl apply -f <file.yaml>: Crea o actualiza recursos definidos en un archivo YAML. ¡Este es el comando más común para el despliegue!

  kubectl apply -f my-deployment.yaml
  kubectl apply -f my-service.yaml

• kubectl create -f <file.yaml>: Crea recursos (no los actualiza si ya existen).
• kubectl delete -f <file.yaml>: Elimina recursos definidos en un archivo YAML.

  kubectl delete -f my-deployment.yaml

• kubectl delete <resource-type> <name>: Elimina un recurso por nombre.

  kubectl delete pod my-nginx-pod
  kubectl delete deployment my-web-app-deployment

• kubectl edit <resource-type> <name>: Abre el editor para modificar un recurso en vivo. ¡Útil para cambios rápidos, pero se pierde el control de versiones!

4.3. Escalado

• kubectl scale deployment <name> --replicas=<count>: Escala un Deployment.

  kubectl scale deployment my-web-app-deployment --replicas=5

4.4. Rollouts (Despliegues)

• kubectl rollout status deployment/<name>: Muestra el estado de un despliegue.
• kubectl rollout history deployment/<name>: Muestra el historial de revisiones del despliegue.
• kubectl rollout undo deployment/<name>: Deshace el último despliegue (rollback).
  • --to-revision=<revision-number>: Para revertir a una revisión específica.

4.5. Configuración de Contexto

• kubectl config get-contexts: Lista los contextos disponibles.
• kubectl config use-context <context-name>: Cambia al contexto especificado.
• kubectl config current-context: Muestra el contexto actual.

---

5. 🌐 Networking Avanzado

5.1. Ingress

Expone Servicios HTTP/HTTPS a clientes externos, proporcionando enrutamiento basado en host o path. Requiere un Ingress Controller (ej. Nginx Ingress Controller, Traefik).

# my-ingress.yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-app-ingress
  annotations: # Anotaciones específicas del Ingress Controller
    nginx.ingress.kubernetes.io/rewrite-target: / # Ejemplo Nginx
spec:
  rules:
    - host: myapp.example.com # Enrutamiento basado en host
      http:
        paths:
          - path: / # Coincide con la ruta raíz
            pathType: Prefix # O Exact
            backend:
              service:
                name: my-web-app-service # El Service a enlazar
                port:
                  number: 80 # Puerto del Service
    - http: # Enrutamiento basado en path (sin host específico)
        paths:
          - path: /api/v1
            pathType: Prefix
            backend:
              service:
                name: my-api-service
                port:
                  number: 8080
  tls: # Configuración TLS/SSL (requiere un Secret con certificado)
    - hosts:
        - myapp.example.com
      secretName: myapp-tls-secret

5.2. NetworkPolicy

Define reglas de firewall para controlar el flujo de tráfico entre Pods, Namespaces y IPs externas.

# my-network-policy.yaml
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-frontend-to-backend
  namespace: default
spec:
  podSelector: # Pods a los que se aplica la política
    matchLabels:
      app: backend
  policyTypes:
    - Ingress # Reglas de entrada
    - Egress # Reglas de salida
  ingress: # Permitir entrada a Pods de backend desde Pods de frontend
    - from:
        - podSelector: # Pods de frontend en el mismo Namespace
            matchLabels:
              app: frontend
      ports:
        - protocol: TCP
          port: 8080 # Puerto que el backend expone
  egress: # Permitir salida a IPs externas
    - to:
        - ipBlock:
            cidr: 0.0.0.0/0 # Cualquier IP externa
      ports:
        - protocol: TCP
          port: 443 # Solo tráfico HTTPS

---

6. 💾 Almacenamiento (Storage)

Para la persistencia de datos más allá del ciclo de vida del Pod.

• PersistentVolume (PV): Un recurso de almacenamiento en el clúster provisionado por un administrador.
• PersistentVolumeClaim (PVC): Una solicitud de almacenamiento por parte de un usuario (Pod).
• StorageClass: Proporciona una forma de aprovisionamiento dinámico de PVs.metadata: name: my-app-secret

type: Opaque # Tipo de secreto (default: Opaque, otros: kubernetes.io/dockerconfigjson, etc.)
data:
  username: dXNlcm5hbWU= # 'username' base64-encoded
  password: cGFzc3dvcmQ= # 'password' base64-encoded
# my-pvc.yaml
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-app-pvc
spec:
  accessModes: # Modos de acceso
    - ReadWriteOnce # Se puede montar como lectura-escritura por un solo nodo
    # - ReadOnlyMany: montado como solo lectura por muchos nodos
    # - ReadWriteMany: montado como lectura-escritura por muchos nodos (depende del proveedor)
  resources:
    requests:
      storage: 1Gi # Solicita 1 Gigabyte de almacenamiento
  storageClassName: standard # Opcional: Nombre de la StorageClass

Para usar en un Pod/Deployment:
    ```yaml
    # En la especificación del Pod (template del Deployment)
    spec:
      volumes: # Define el volumen referenciando la PVC
        - name: my-storage
          persistentVolumeClaim:
            claimName: my-app-pvc
      containers:
        - name: my-container
          image: busybox
          command: ["sh", "-c", "echo 'Hello from volume' > /data/hello.txt && cat /data/hello.txt"]
          volumeMounts: # Monta el volumen dentro del contenedor
            - name: my-storage
              mountPath: "/data" # Ruta dentro del contenedor donde se montará el volumen```

7. 🔒 Seguridad (RBAC y Secrets)

7.1. RBAC (Role-Based Access Control)

Controla quién puede hacer qué en tu clúster.

• ServiceAccount: Una identidad para los procesos que se ejecutan en un Pod.
• Role: Define permisos dentro de un Namespace.
• ClusterRole: Define permisos a nivel de clúster.
• RoleBinding: Otorga un Role a un ServiceAccount (o usuario/grupo) dentro de un Namespace.
• ClusterRoleBinding: Otorga un ClusterRole a un ServiceAccount (o usuario/grupo) a nivel de clúster.

# my-serviceaccount.yaml
apiVersion: v1
kind: ServiceAccount
metadata:
  name: my-app-sa

# my-role.yaml (en un Namespace específico)
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  namespace: default
  name: pod-reader
rules:
  - apiGroups: [""] # "" indica el core API group
    resources: ["pods", "pods/log"]
    verbs: ["get", "watch", "list"]

# my-rolebinding.yaml
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: read-pods-binding
  namespace: default
subjects:
  - kind: ServiceAccount
    name: my-app-sa
    namespace: default
roleRef: # Referencia al Role o ClusterRole
  kind: Role # Debe ser Role para RoleBinding
  name: pod-reader
  apiGroup: rbac.authorization.k8s.io

7.2. Secrets (Revisado)

Para almacenar información sensible (contraseñas, tokens, claves API).

• Los valores deben estar codificados en Base64.
• Se pueden montar como archivos en el sistema de archivos del Pod o como variables de entorno.

# En un Pod/Deployment spec
spec:
  containers:
    - name: my-secure-app
      image: my-app-image
      env: # Inyectar como variables de entorno
        - name: DB_USERNAME
          valueFrom:
            secretKeyRef:
              name: my-db-secret # Nombre del Secret
              key: username      # Clave dentro del Secret
      volumeMounts: # Montar como archivos
        - name: db-credentials
          mountPath: "/etc/secrets"
          readOnly: true
  volumes:
    - name: db-credentials
      secret:
        secretName: my-db-secret

---

8. 💡 Buenas Prácticas y Consejos

• Namespaces: Utiliza namespaces para organizar recursos y aislar entornos (desarrollo, staging, producción) o equipos.
• Liveness y Readiness Probes: Define estas sondas en tus Pods para que Kubernetes sepa cuándo reiniciar un contenedor (liveness) y cuándo está listo para recibir tráfico (readiness).
• Requests y Limits: Siempre define resources.requests y resources.limits para tus contenedores. Esto ayuda al scheduler a ubicar tus Pods y previene que un Pod consuma todos los recursos del nodo.
• Labels y Selectors: Usa etiquetas de manera consistente para organizar tus recursos y permitir que los Deployments y Services seleccionen los Pods correctos.
• Despliegues (Deployment): Siempre usa Deployments (o StatefulSets para aplicaciones con estado) en lugar de Pods directamente. Proporcionan auto-reparación, escalado y actualizaciones controladas.
• Contenedores Inmutables: Una vez que una imagen de contenedor se construye, no la modifiques. Para cambios, construye una nueva imagen y despliega una nueva versión.
• Gestión de Logs y Monitoreo: Configura un sistema centralizado de logs (ej. ELK Stack, Grafana Loki) y herramientas de monitoreo (ej. Prometheus, Grafana) para observar el rendimiento y la salud de tu clúster y aplicaciones.
• Evita latest Tag: Usa tags de imagen específicos (ej. nginx:1.21.6) en lugar de latest para garantizar despliegues reproducibles.
• Seguridad:
  • Implementa RBAC con el principio de menor privilegio.
  • No incluyas secretos directamente en tu código o Dockerfiles.
  • Considera herramientas de gestión de secretos para producción.
• Docker Compose para Desarrollo: Usa Docker Compose para configurar tu entorno de desarrollo local.
• Helm: Para gestionar despliegues de aplicaciones complejas. Es un gestor de paquetes para Kubernetes.
• Clústeres Gestionados: Para producción, considera usar servicios de Kubernetes gestionados por proveedores de nube (GKE, EKS, AKS).

---

Este cheatsheet te proporciona una referencia completa de Kubernetes, cubriendo sus conceptos esenciales, objetos, comandos kubectl, networking, almacenamiento, seguridad y las mejores prácticas para construir y gestionar aplicaciones en contenedores a escala.