KUBERNETES & SEGURIDAD · 16 de noviembre de 2026

Seguridad en Kubernetes: por qué un clúster «seguro» deja pasar lo importante y cómo auditarlo en AKS, EKS y GKE

Cómo auditar la seguridad de Kubernetes en AKS, EKS y GKE: NetworkPolicy, Pod Security, RBAC e identidad del nodo, por su efecto y no por existir.

Un escudo con una llave en el centro, sobre un fondo de líneas onduladas

Controles que existen sin hacer lo que prometen

Un clúster puede tener NetworkPolicies, etiquetas de Pod Security y roles «de solo lectura», y aun así dejar pasar lo importante. Varios controles de Kubernetes fallan en silencio: existen sin hacer lo que su nombre promete.

Además, se protegen unos a otros en cadena. Si los auditas por separado y solo compruebas que existen, el resultado da una seguridad que no se corresponde con la realidad. Este artículo sigue la cadena en orden y propone, para cada eslabón, cómo comprobar el efecto.

*Alcance:* el artículo cubre el interior del clúster. El acceso al clúster desde el IAM de cada nube (Microsoft Entra ID y Azure RBAC, access entries de EKS, Cloud IAM) queda fuera y no lo hemos revisado aquí.

Cuatro controles que dependen unos de otros

Piensa en un objetivo concreto: que un pod comprometido no obtenga credenciales de la nube con la identidad del nodo. Para conseguirlo dependes de cuatro eslabones:

1. Red. Una NetworkPolicy impide al pod llegar al endpoint de metadatos del proveedor. Solo sirve si hay un motor que la aplique.

2. Pod Security. Un pod con hostNetwork: true comparte la red del nodo y queda fuera de varias de estas protecciones (lo vemos en el apartado 4). Lo que lo impide es Pod Security Admission en nivel baseline o restricted.

3. Namespace. Pod Security se configura con etiquetas del namespace, así que quien pueda modificarlas puede relajarla.

4. RBAC. Quien tenga patch sobre el namespace puede cambiar esas etiquetas, según la guía de buenas prácticas de RBAC.

Una auditoría que marca «NetworkPolicy: sí, Pod Security: sí, RBAC revisado» puede dar por bueno un clúster en el que cualquiera de los cuatro eslabones está roto. Vamos uno por uno, con cómo comprobar que funciona y no solo que existe.

1. NetworkPolicy: que exista no significa que se aplique

La documentación oficial lo dice así: crear una NetworkPolicy sin un controlador que la implemente no tiene ningún efecto (Network Policies). El objeto se crea, kubectl get networkpolicy lo muestra y el tráfico sigue pasando.

En cada proveedor, el motor depende de la configuración:

Qué hay que comprobar
EKSEl VPC CNI aplica NetworkPolicy solo si se activa enableNetworkPolicy. Para políticas estándar y de administración se necesita la versión 1.21 o posterior. Por defecto (*standard mode*), un pod nuevo arranca permitiendo todo hasta que se le aplican las políticas. Con NETWORK_POLICY_ENFORCING_MODE=strict arranca denegando. Solo se aplica en nodos EC2 Linux, no en Fargate ni en Windows, y en pods sueltos sin controlador puede no aplicarse de forma fiable (EKS network policy, configuración)
AKSHay que elegir motor: Cilium, Azure NPM o Calico. Con --network-policy none, las políticas existen pero no se aplican. Azure NPM deja de estar soportado en nodos Linux el 30/09/2028, y en nodos Windows dejó de estarlo el 30/09/2026 (AKS network policies)
GKECon GKE Dataplane V2, la aplicación de políticas está integrada y no se puede desactivar, y Autopilot lo usa por defecto. Sin Dataplane V2 hay que activar tanto el complemento NetworkPolicy como su aplicación en los nodos (GKE network policy)

Otro límite de la API: la API estándar de NetworkPolicy no permite políticas por defecto que se apliquen a todos los namespaces ni denegaciones explícitas. Las políticas son aditivas, y cada pod que no selecciona ninguna política acepta todo el tráfico. Por tanto, si solo usas NetworkPolicy, cada namespace nuevo nace abierto hasta que alguien le añade su política de denegación. Algunos motores ofrecen políticas de ámbito de clúster que cubren este hueco (en EKS, ClusterNetworkPolicy con VPC CNI 1.21 o posterior). Si las usas, revísalas junto con las del namespace. El punto de partida de la documentación:

yamlENGINEERING
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny-all
  namespace: tienda
spec:
  podSelector: {}
  policyTypes:
    - Ingress
    - Egress

Denegar la salida también corta el DNS, como advierte la propia documentación. Necesitas una política explícita:

yamlENGINEERING
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-dns
  namespace: tienda
spec:
  podSelector: {}
  policyTypes:
    - Egress
  egress:
    - to:
        - namespaceSelector:
            matchLabels:
              kubernetes.io/metadata.name: kube-system
          podSelector:
            matchLabels:
              k8s-app: kube-dns
      ports:
        - protocol: UDP
          port: 53
        - protocol: TCP
          port: 53

Si usas una caché DNS en el nodo (por ejemplo, LocalDNS en AKS, que puede activarse al subir node pools a 1.37; lo explicamos en el artículo sobre upgrades), el tráfico DNS puede no ir a esos pods. Compruébalo en tu clúster antes de dar la política por buena.

Cómo saber qué namespaces no tienen ninguna NetworkPolicy (requiere bash):

bashENGINEERING
comm -23 \
  <(kubectl get ns -o jsonpath='{range .items[*]}{.metadata.name}{"\n"}{end}' | sort) \
  <(kubectl get networkpolicy -A -o jsonpath='{range .items[*]}{.metadata.namespace}{"\n"}{end}' | sort -u)

Cómo saber si hay motor:

bashENGINEERING
# EKS (VPC CNI autogestionado o add-on)
kubectl get ds aws-node -n kube-system -o yaml | grep -- '--enable-network-policy=true'   # sin salida = no se aplican políticas
aws eks describe-addon --cluster-name <cluster> --addon-name vpc-cni --query addon.configurationValues
# AKS
az aks show --resource-group <grupo> --name <cluster> --query networkProfile.networkPolicy -o tsv
# GKE con Dataplane V2:
kubectl -n kube-system get pods -l k8s-app=cilium   # sin salida = no se aplican políticas
# GKE sin Dataplane V2:
kubectl get nodes -l projectcalico.org/ds-ready=true   # sin salida = no se aplican políticas

En AKS, none o un resultado vacío significan que no se aplica ninguna política. Aun así, la prueba definitiva es de efecto: dos pods en un namespace de pruebas, una política que debería bloquear el tráfico entre ellos y un intento de conexión. La documentación de AKS lo detalla paso a paso.

2. Pod Security Admission: el Deployment entra, los pods no

Pod Security Admission (estable desde la 1.25) tiene tres modos: enforce rechaza el pod, audit lo anota en el log de auditoría y warn avisa al usuario. La clave está en esta frase de la documentación: audit y warn se aplican a los recursos de workload, pero enforce solo a los pods resultantes.

En la práctica: aplicas un Deployment que incumple restricted en un namespace con enforce y kubectl apply termina sin errores. El Deployment existe, su ReplicaSet también, y no hay pods. El rechazo solo aparece en los eventos del ReplicaSet. Si no tienes warn activado, quien despliega no ve nada. Si te pasa lo contrario y no tienes enforce, tienes avisos y nada que bloquee.

bashENGINEERING
kubectl get events -A --field-selector reason=FailedCreate
kubectl get ns -L pod-security.kubernetes.io/enforce,pod-security.kubernetes.io/enforce-version

Antes de endurecer un nivel, la documentación propone una simulación en el servidor que avisa de qué pods actuales lo incumplirían, sin cambiar nada (aplicar estándares con etiquetas):

bashENGINEERING
kubectl label --dry-run=server --overwrite ns --all pod-security.kubernetes.io/enforce=baseline

Nuestro criterio para las versiones de la política es fijar enforce a la versión del clúster y dejar warn y audit en latest. Así, los avisos te anticipan lo que endurecerá la próxima versión antes de que bloquee nada:

yamlENGINEERING
apiVersion: v1
kind: Namespace
metadata:
  name: tienda
  labels:
    pod-security.kubernetes.io/enforce: restricted
    pod-security.kubernetes.io/enforce-version: v1.37
    pod-security.kubernetes.io/warn: restricted
    pod-security.kubernetes.io/warn-version: latest
    pod-security.kubernetes.io/audit: restricted
    pod-security.kubernetes.io/audit-version: latest

Con las exenciones, cuidado: la documentación advierte de que eximir cuentas de servicio de controladores (como la del controlador de ReplicaSet) exime en la práctica a cualquiera que pueda crear ese tipo de workload.

3. RBAC: los permisos «de lectura» que no lo son

La guía de buenas prácticas de RBAC enumera caminos de escalada que no se ven en una revisión rápida de roles:

list y watch sobre Secrets revelan su contenido, igual que get.
get sobre nodes/proxy no es de lectura: da acceso a la API del kubelet, que permite ejecutar comandos en los pods de esos nodos.
Crear pods o workloads en un namespace da acceso implícito a sus Secrets, ConfigMaps y volúmenes, y a los permisos de cualquier ServiceAccount de ese namespace.
escalate, bind e impersonate se saltan las protecciones de RBAC contra la escalada.
create sobre serviceaccounts/token permite emitir tokens de cuentas existentes.
Controlar webhooks de admisión permite leer, y si son de mutación también modificar, todo lo que entra en el clúster.
patch sobre Namespaces permite cambiar sus etiquetas, incluidas las de Pod Security.
El grupo system:masters se salta RBAC y no se revoca borrando bindings.

Para auditar, no leas solo los roles: pregunta qué puede hacer cada identidad.

bashENGINEERING
SA=system:serviceaccount:tienda:despliegue-ci
kubectl auth can-i --list -n tienda --as=$SA
kubectl auth can-i list secrets -n tienda --as=$SA
kubectl auth can-i get nodes --subresource=proxy --as=$SA
kubectl auth can-i patch namespaces --as=$SA
kubectl auth can-i create pods -n tienda --as=$SA

Y para encontrar roles con verbos de escalada (verás ruido de roles del sistema, como cluster-admin; revísalo igualmente):

bashENGINEERING
kubectl get clusterroles,roles -A -o json | jq -r '
  .items[]
  | select([.rules[]?.verbs[]?] | any(. == "escalate" or . == "bind" or . == "impersonate" or . == "*"))
  | "\(.kind)\t\(.metadata.namespace // "-")\t\(.metadata.name)"'

4. Identidad del workload: el pod que puede heredar la identidad del nodo

Aquí se cierra la cadena. Cada proveedor resuelve de forma distinta el acceso de los pods a los metadatos del nodo:

EKS. Aunque uses IRSA o EKS Pod Identity, la guía de buenas prácticas de EKS avisa de que el pod puede seguir heredando los permisos del perfil de instancia del nodo. Recomienda exigir IMDSv2 con un límite de saltos de 1, sin desactivar los metadatos, porque hay componentes que los necesitan (EKS IAM best practices). La guía de network policy de EKS advierte, a su vez, de que una NetworkPolicy puede bloquear IMDS a pods que sí lo necesitan (EKS network policy).
AKS. Por defecto, todos los pods pueden llegar al endpoint IMDS (169.254.169.254). La restricción gestionada (--enable-imds-restriction) está en preview, no es para producción y es incompatible con varios add-ons (AKS IMDS restriction). Mientras tanto, la vía habitual es Microsoft Entra Workload ID para los pods más una NetworkPolicy de salida.
GKE. Con Workload Identity Federation for GKE, el servidor de metadatos de GKE intercepta las peticiones de los pods a metadata.google.internal y los pods dejan de acceder al servidor de metadatos de Compute Engine. Excepción: los pods con hostNetwork: true no usan Workload Identity y sus peticiones van al servidor de metadatos de Compute Engine (GKE Workload Identity).

Para EKS y AKS, en namespaces que aún no restringen la salida:

yamlENGINEERING
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-egress-except-metadata
  namespace: tienda
spec:
  podSelector: {}
  policyTypes:
    - Egress
  egress:
    - to:
        - ipBlock:
            cidr: 0.0.0.0/0
            except:
              - 169.254.169.254/32

Que esta política bloquee de verdad el tráfico a 169.254.169.254 depende del motor de red, y la documentación de Kubernetes no lo garantiza. Compruébalo con la prueba de efecto del final antes de darlo por cerrado.

Dos trampas. La primera es que las políticas son aditivas: si otra política del namespace permite 0.0.0.0/0 sin except, el endpoint vuelve a estar abierto. La segunda es que en GKE con Workload Identity no la apliques así, porque los pods obtienen sus credenciales precisamente a través de ese servidor de metadatos.

Y lo que conecta con el apartado 2: hostNetwork: true deja al pod fuera de estas protecciones en los tres proveedores. En EKS, el modo estricto no se aplica a pods con red de host. En AKS, la restricción de IMDS no les afecta. En GKE, no usan Workload Identity. Además, la documentación de Kubernetes define como «undefined» el comportamiento de NetworkPolicy con pods hostNetwork, y la implementación más común los ignora. Por eso Pod Security en baseline o restricted, que no permiten hostNetwork, forma parte del control de identidad y no es un tema aparte.

Por último, si una aplicación no llama a la API de Kubernetes, automountServiceAccountToken: false. La guía de RBAC lo recomienda y la de EKS propone aplicarlo también a la cuenta default de cada namespace.

Errores habituales y cómo detectarlos

ErrorCómo detectarlo
NetworkPolicy sin motor que la apliqueComando del motor por proveedor y prueba de efecto con dos pods
EKS en *standard mode* dando por hecho que los pods arrancan aisladosVariable NETWORK_POLICY_ENFORCING_MODE en aws-node
Namespaces sin ninguna NetworkPolicyComando comm de arriba (un namespace con políticas que no seleccionan todos sus pods sigue parcialmente abierto)
Denegar la salida y romper el DNSFallos de resolución tras aplicar default-deny-all en pruebas
Deployment «desplegado» sin pods por Pod SecurityEventos FailedCreate en los ReplicaSet
Namespaces sin etiqueta enforcekubectl get ns -L pod-security.kubernetes.io/enforce
Roles «de lectura» con list sobre Secrets o get sobre nodes/proxykubectl auth can-i por identidad
Bloqueo de IMDS anulado por otra política más ampliaRevisar todas las políticas de salida del namespace juntas, no una a una
Pods con hostNetwork en namespaces de aplicaciónkubectl get pods -A -o jsonpath='{range .items[?(@.spec.hostNetwork==true)]}{.metadata.namespace}/{.metadata.name}{"\n"}{end}'

Orden de comprobación

Primero, solo lectura y en este orden, porque sigue la cadena:

1. Motor de red. Comandos del apartado 1 para tu proveedor.

2. Cobertura de red. Namespaces sin NetworkPolicy.

3. Pod Security. Etiquetas enforce por namespace y eventos FailedCreate.

4. hostNetwork. Pods con red de host fuera de kube-system.

5. RBAC. kubectl auth can-i para las identidades de CI/CD, operadores y equipos, empezando por patch namespaces, list secrets, nodes/proxy y create pods.

6. Identidad. Configuración de metadatos de los nodos (IMDSv2 y límite de saltos en EKS; IMDS restriction o NetworkPolicy en AKS; Workload Identity en GKE).

Después, en un namespace de pruebas y fuera de producción: prueba de efecto de la NetworkPolicy entre dos pods y un intento de conexión al endpoint de metadatos desde un pod sin hostNetwork. Debe agotar el tiempo de espera.

Por dónde empezar

1. Comprueba que hay motor de NetworkPolicy. Si no lo hay, tus políticas actuales no protegen nada, y conviene saberlo cuanto antes.

2. Lista los namespaces sin política de denegación y sin etiqueta enforce: son dos huecos que se repiten con cada namespace nuevo si nadie los cierra.

3. Ejecuta kubectl auth can-i --list para la identidad de tu pipeline de despliegue. Por diseño tiene permisos de escritura amplios, así que es la primera que conviene revisar.

4. Decide cómo bloqueas en tu proveedor el acceso de los pods a la identidad del nodo y prueba que el bloqueo funciona.

En Nubyron trabajamos la seguridad en Kubernetes en AKS, EKS y GKE: RBAC, políticas y endurecimiento según las guías CIS. Si quieres que revisemos la cadena completa en tu clúster, escríbenos.

Fuentes (consultadas el 16/11/2026)

Network Policies (Kubernetes 1.37)
Pod Security Admission (estable desde 1.25)
Enforce Pod Security Standards with namespace labels
RBAC good practices
EKS, network policy
EKS, configurar network policy
EKS Best Practices, IAM
AKS, network policies
AKS, IMDS restriction (preview)
GKE, network policy
GKE, Workload Identity Federation

Las salidas de comandos son ilustrativas y no se han capturado de un clúster real. Las opciones de cada proveedor cambian: comprueba siempre su documentación antes de actuar.

Preguntas frecuentes

¿Por qué una NetworkPolicy puede no tener ningún efecto?

Porque según la documentación de Kubernetes, crear una NetworkPolicy sin un controlador que la implemente no tiene ningún efecto: el objeto existe y el tráfico sigue pasando. En AKS, con network-policy none, las políticas existen pero no se aplican; en EKS hay que activar la aplicación en el VPC CNI; en GKE, sin Dataplane V2, hay que activar el complemento y su aplicación en los nodos.

¿Qué ocurre con un Deployment que incumple Pod Security en modo enforce?

Según la documentación, enforce solo actúa sobre los pods resultantes, no sobre el Deployment. kubectl apply termina sin errores, el Deployment y su ReplicaSet existen y no hay pods; el rechazo aparece en los eventos del ReplicaSet. Con warn activado, quien despliega recibe un aviso.

¿Puede ser peligroso un rol «de solo lectura» en Kubernetes?

Sí. Según la guía de buenas prácticas de RBAC, list y watch sobre Secrets revelan su contenido igual que get, y get sobre nodes/proxy da acceso a la API del kubelet. Por eso conviene preguntar qué puede hacer cada identidad con kubectl auth can-i y no revisar solo los roles.

¿Cómo compruebo que un control de seguridad funciona y no solo que existe?

Con una prueba de efecto: por ejemplo, dos pods en un namespace de pruebas, una NetworkPolicy que debería bloquear el tráfico entre ellos y un intento de conexión. Para RBAC, kubectl auth can-i por identidad. Para Pod Security, los eventos FailedCreate de los ReplicaSet.

¿Quieres que revisemos la cadena de controles de tu clúster?

Trabajamos la seguridad en Kubernetes en AKS, EKS y GKE: RBAC, políticas y endurecimiento según las guías CIS. Podemos revisar tu caso contigo y decirte por dónde empezar.

Ver seguridad en Kubernetes

Hablar con Nubyron ↗