Seguridad
La seguridad en Kubernetes se monta por capas: comprobar quién eres, decidir qué puedes hacer, revisar lo que pides antes de aceptarlo y vigilar lo que pasa mientras funciona.
Las 4C: seguridad por capas
La documentación de Kubernetes resume la seguridad con un dibujo de cuatro capas, una dentro de otra, que empiezan todas por C: Cloud, Cluster, Container y Code. La idea es sencilla: cada capa depende de la de fuera. Si la de fuera falla, lo que hagas dentro sirve de poco.
Piensa en un banco. Primero está el edificio (cloud: muros, alarma, quién tiene llaves del local). Dentro, la oficina (cluster: quién puede pasar del mostrador). Dentro, la cámara acorazada (container: qué hay en cada caja y quién la abre). Y dentro de cada caja, lo que guardas (code: tu propia aplicación).
Si alguien entra por una ventana del edificio sin cerrar, da igual lo buena que sea la cerradura de la cámara.
Las tres puertas de la API
En la lección 02 viste que todo pasa por el API server. Por eso es el sitio donde se hace la mayor parte del control. Cada petición, venga de una persona con kubectl o de un programa, atraviesa tres puertas en orden:
- Autenticación (authentication, abreviado authn): ¿quién eres? Se comprueba la identidad con un certificado, un token o un proveedor de identidad externo (OIDC, como el login de Google o de la empresa).
- Autorización (authorization, abreviado authz): ¿puedes hacer esto? Ya se sabe quién eres; ahora se mira si tienes permiso para esa acción concreta. Lo normal es usar RBAC, que vemos enseguida.
- Control de admisión (admission control): ¿lo que pides es aceptable? Tienes permiso para crear Pods, pero ¿este Pod en concreto cumple las normas de la casa?
Sólo si pasa las tres, lo que pides se guarda en etcd y el clúster se pone a trabajar.
Es como entrar a un concierto. En la puerta te piden el DNI (autenticación). Luego miran tu entrada: ¿es de pista o de grada VIP? (autorización). Y por último pasas el control de bolsos: aunque tengas entrada, no puedes meter una botella de cristal (admisión). En ese control, además, a veces te ponen una pulsera: eso es una admisión que modifica.
El orden es siempre autenticación → autorización → admisión. Primero quién eres, luego qué puedes hacer, y por último si lo que pides cumple las normas.
Otra curiosidad que sale: Kubernetes no guarda usuarios humanos. No existe un objeto «User» que puedas crear. Las personas se identifican con certificados o con un sistema externo; Kubernetes sólo lee el nombre que viene en esa identificación.
RBAC: quién puede hacer qué
RBAC (Role-Based Access Control, control de acceso basado en roles) es la forma estándar de dar permisos en Kubernetes. Funciona con dos piezas que se separan a propósito:
- El rol: una lista de permisos. Dice qué acciones (verbs: get, list, create, delete…) se pueden hacer sobre qué tipo de objetos (resources: pods, deployments, secrets…).
- La asignación (binding): une un rol con alguien: una persona, un grupo o un programa.
En un hotel, el rol es la descripción del puesto: «camarera de pisos: puede abrir habitaciones y reponer toallas». La asignación es el contrato: «Lucía trabaja como camarera de pisos en la planta 3». El puesto se define una vez y se asigna a quien haga falta.
Cada pieza tiene dos versiones, según su alcance:
| Sólo en un Namespace | En todo el clúster | |
|---|---|---|
| Lista de permisos | Role | ClusterRole |
| Asignación | RoleBinding | ClusterRoleBinding |
Tres ideas clave de RBAC:
- Sólo suma, nunca resta. No existen reglas de «prohibido». Por defecto no se puede hacer nada, y cada rol añade permisos.
- Mínimo privilegio (least privilege): dar a cada uno sólo los permisos que necesita para su trabajo, ni uno más.
- Un RoleBinding también puede apuntar a un ClusterRole: así se define un rol común una vez («lector») y se concede dentro de un solo Namespace.
ServiceAccount: la identidad de los programas
Las personas no son las únicas que hablan con la API. Muchas aplicaciones también lo hacen: un programa de copias de seguridad, una herramienta de despliegue, un Operator. Para ellos existe la ServiceAccount (ServiceAccount, cuenta de servicio): una identidad para programas que, a diferencia de los usuarios humanos, sí es un objeto de Kubernetes y vive en un Namespace.
Cada Pod se ejecuta con una ServiceAccount. Si no dices cuál, usa la que se llama default de su Namespace. Los permisos se le dan igual que a una persona: con un RoleBinding.
Tu equipo instala una herramienta que vigila los Pods y avisa si alguno falla. Para que funcione, le creas una ServiceAccount «vigilante» y le das un rol que sólo permite get, list y watch sobre Pods. Si algún día alguien se cuela en esa herramienta, sólo podrá mirar Pods: no podrá borrar nada ni leer contraseñas.
El control de admisión: las normas de la casa
Los controladores de admisión (admission controllers) revisan cada petición que ya ha pasado autenticación y autorización. Hay dos tipos, y actúan en este orden:
- Los que modifican (mutating): pueden cambiar la petición antes de guardarla. Por ejemplo, añadir valores por defecto que faltan o meter automáticamente un contenedor ayudante (sidecar) en cada Pod.
- Los que validan (validating): sólo dicen sí o no. Por ejemplo, rechazar un Pod que usa una imagen de un registro no autorizado.
Kubernetes trae varios de serie (algunos ya los conoces: el que aplica LimitRange y el de ResourceQuota, de la lección 05). Y se pueden añadir los tuyos con webhooks: el API server le pregunta a un programa externo «¿acepto esto?».
Herramientas de normas: OPA Gatekeeper y Kyverno
Escribir un webhook desde cero es trabajo de programador. Por eso existen herramientas que hacen de controlador de admisión y en las que sólo escribes las normas:
- OPA Gatekeeper: usa el motor Open Policy Agent (OPA), un proyecto de la CNCF. Las normas se escriben en un lenguaje propio llamado Rego.
- Kyverno: hace lo mismo, pero las normas se escriben en YAML, como cualquier otro objeto de Kubernetes. Puede validar, modificar e incluso generar objetos.
Ejemplos de normas típicas: «todo Pod debe tener la etiqueta equipo», «prohibido usar la etiqueta de imagen latest», «sólo imágenes de nuestro registro».
Pod Security Standards: tres niveles de exigencia
Un contenedor puede pedir cosas peligrosas: ejecutarse como administrador (root), tener acceso total al servidor (privileged), usar la red del propio nodo… Para no tener que inventar las normas cada vez, Kubernetes define tres niveles estándar, los Pod Security Standards:
¿Quién hace cumplir esos niveles? Un controlador de admisión que viene de serie: Pod Security Admission. Se activa por Namespace, poniéndole una etiqueta, y tiene tres modos:
- enforce: rechaza los Pods que no cumplen.
- audit: los deja pasar, pero lo anota en el registro de auditoría.
- warn: los deja pasar y muestra un aviso a quien lo creó.
# Este Namespace sólo acepta Pods que cumplan el nivel «restricted» apiVersion: v1 kind: Namespace metadata: name: pagos labels: pod-security.kubernetes.io/enforce: restricted
Antes existía un objeto llamado PodSecurityPolicy (PSP). Se eliminó en la versión 1.25. Su sustituto es Pod Security Admission, que aplica los Pod Security Standards. Si una respuesta propone PSP como solución actual, es incorrecta.
securityContext: la configuración de seguridad de cada Pod
Dentro de la definición de un Pod o de un contenedor hay un apartado, securityContext, donde se dice cómo debe ejecutarse. Es lo que miran los niveles de arriba para decidir si el Pod cumple. Los ajustes más típicos:
securityContext: runAsNonRoot: true # prohibido ejecutarse como administrador runAsUser: 1000 # con este usuario normal readOnlyRootFilesystem: true # no puede escribir en sus propios ficheros allowPrivilegeEscalation: false # no puede ganar más poder por el camino capabilities: drop: ["ALL"] # sin permisos especiales de Linux
Con esto, aunque un atacante consiga meterse en el contenedor, tiene muy poco margen: no es administrador, no puede instalar nada ni cambiar los ficheros del programa.
Proteger los Secrets
En la lección 03 viste que un Secret sólo está escrito en base64, que no es cifrado, y que por defecto se guarda tal cual en etcd. Para protegerlo de verdad se combinan varias medidas:
- Cifrado en reposo (encryption at rest): se configura el API server para que cifre los Secrets antes de guardarlos en etcd. Lo más seguro es que la llave la guarde un servicio externo de llaves (KMS), no el propio clúster.
- RBAC estricto: muy poca gente y muy pocos programas deberían tener permiso para leer Secrets.
- Gestores de secretos externos, como HashiCorp Vault o los de cada nube, que guardan las contraseñas fuera del clúster y las entregan cuando hacen falta.
La cadena de suministro: desde el código hasta el clúster
Una imagen pasa por muchas manos antes de ejecutarse: librerías de terceros, la imagen base, el sistema que la construye, el registro… Proteger ese camino se llama seguridad de la cadena de suministro (supply chain security).
Es como la seguridad alimentaria. La lista de ingredientes de la etiqueta te dice qué lleva el producto (SBOM). La inspección sanitaria busca algo en mal estado (escaneo). El precinto te garantiza que nadie lo ha abierto desde la fábrica (firma). Y en la tienda no aceptan género sin precinto (admisión).
- SBOM (Software Bill of Materials): la lista de ingredientes de la imagen, con cada librería y su versión. Si mañana se descubre un fallo en una librería, sabes al momento qué imágenes la llevan.
- Escaneo de imágenes (image scanning): herramientas como Trivy comparan lo que lleva la imagen con bases de datos de fallos de seguridad conocidos (CVE).
- Firma de imágenes (image signing): con el proyecto Sigstore y su herramienta cosign se firma la imagen. Así se puede comprobar quién la hizo y que nadie la ha cambiado.
- Verificar al admitir: un controlador de admisión (Kyverno, por ejemplo) rechaza las imágenes sin firma válida.
Vigilar mientras funciona: Falco
Todo lo anterior actúa antes de que el contenedor arranque. Pero ¿y si alguien encuentra un fallo en tu aplicación y se mete dentro cuando ya está en marcha? Para eso hay herramientas de detección en ejecución (runtime security). La más conocida es Falco, un proyecto de la CNCF.
Falco observa lo que hacen los contenedores a muy bajo nivel (las llamadas al sistema operativo) y avisa cuando ve algo raro: alguien abre una terminal dentro de un contenedor de producción, se lee un fichero de contraseñas del sistema, un programa inesperado abre una conexión de red…
Gatekeeper y Kyverno actúan en la puerta: deciden si algo entra. Falco actúa dentro: vigila lo que ya está funcionando, como una cámara de seguridad.
Y la red
Recuerda de la lección anterior que, por defecto, todos los Pods pueden hablar con todos. Limitar eso con NetworkPolicy también es una medida de seguridad: si un atacante entra en un Pod, no podrá saltar a los demás.
Resumen en cinco frases
- La seguridad va por capas, las 4C: Cloud, Cluster, Container y Code, y cada una depende de la de fuera.
- Toda petición a la API pasa en orden por autenticación (quién eres), autorización (qué puedes hacer) y admisión (si cumple las normas).
- RBAC da permisos con roles (qué) y bindings (quién), sólo suma, y se aplica el mínimo privilegio; los programas usan ServiceAccounts.
- Pod Security Admission aplica tres niveles (privileged, baseline, restricted) y sustituye a PodSecurityPolicy, eliminada en la 1.25.
- La cadena de suministro se protege con SBOM, escaneo y firma de imágenes, y en ejecución Falco vigila comportamientos sospechosos.
Términos del examen
- 4C
- Las cuatro capas de seguridad: Cloud, Cluster, Container, Code.
- Authentication
- Comprobar quién eres.
- Authorization
- Decidir si puedes hacer una acción concreta.
- Admission controller
- Revisa lo que pides y puede modificarlo (mutating) o rechazarlo (validating).
- RBAC
- Permisos por roles. Sólo suma permisos, nunca los quita.
- Role · ClusterRole
- Lista de permisos en un Namespace o en todo el clúster.
- RoleBinding · ClusterRoleBinding
- Une un rol con personas, grupos o ServiceAccounts.
- ServiceAccount
- Identidad de un programa o Pod para hablar con la API.
- Least privilege
- Mínimo privilegio: sólo los permisos imprescindibles.
- Pod Security Standards
- Tres niveles: Privileged, Baseline y Restricted.
- Pod Security Admission
- El controlador de serie que aplica esos niveles por Namespace (enforce, audit, warn).
- PodSecurityPolicy
- El sistema antiguo, eliminado en la 1.25.
- securityContext
- Ajustes de seguridad de un Pod o contenedor (runAsNonRoot, readOnlyRootFilesystem…).
- Encryption at rest
- Cifrar los datos guardados en etcd, sobre todo los Secrets.
- SBOM
- La lista de ingredientes de una imagen.
- Sigstore · cosign
- Proyecto y herramienta para firmar y verificar imágenes.
- OPA Gatekeeper · Kyverno
- Herramientas para escribir normas de admisión (Rego o YAML).
- Falco
- Detecta comportamientos sospechosos en contenedores en marcha.
Comprueba que lo has entendido
1. In which order does the API server process a request?
- Authorization, authentication, admission control
- Admission control, authentication, authorization
- Authentication, authorization, admission control
- Authentication, admission control, authorization
Ver respuesta
C. Primero quién eres (DNI), luego si tienes permiso (entrada) y por último si lo que pides cumple las normas (control de bolsos).
2. Which RBAC object defines a set of permissions that apply only inside one namespace?
- ClusterRole
- Role
- RoleBinding
- ServiceAccount
Ver respuesta
B. El Role es la lista de permisos de un Namespace. El RoleBinding no define permisos: los asigna a alguien. ClusterRole vale para todo el clúster.
3. What identity does a Pod use to authenticate to the Kubernetes API?
- A User object
- The node's certificate
- A ServiceAccount
- A Secret named "admin"
Ver respuesta
C. Los Pods usan una ServiceAccount; si no se indica, la «default» de su Namespace. Los objetos User no existen en Kubernetes.
4. Which mechanism replaced PodSecurityPolicy, removed in Kubernetes 1.25?
- NetworkPolicy
- Pod Security Admission
- ResourceQuota
- RBAC
Ver respuesta
B. Pod Security Admission aplica los Pod Security Standards (privileged, baseline, restricted) en cada Namespace.
5. Which CNCF project detects suspicious behaviour in running containers, such as a shell opened inside a container?
- Falco
- Kyverno
- cosign
- Harbor
Ver respuesta
A. Falco vigila en ejecución, como una cámara de seguridad. Kyverno actúa en la admisión, cosign firma imágenes y Harbor es un registro.