← Volver al blog de ciberseguridad

Qué registra el API server de Kubernetes y cómo convertirlo en detección en EKS, AKS y GKE

Por Daniel O'Grady · CIO y socio fundador · Publicado: 20 de noviembre de 2026 · Actualizado: 20 de noviembre de 2026
Qué registra el API server de Kubernetes y cómo convertirlo en detección

En Amazon EKS el registro de auditoría del API server de Kubernetes viene apagado. La documentación de AWS es explícita: cada tipo de registro del plano de control está desactivado por defecto y hay que activarlo uno a uno. En AKS tampoco llega a ningún sitio hasta que alguien crea una configuración de diagnóstico. Solo GKE guarda de serie una parte, la de escrituras, y deja las lecturas fuera salvo que se paguen.

Las cifras que Unit 42 publicó en abril de 2026 agravan el problema: la actividad de atacantes dirigida a Kubernetes creció un 282 % en un año y los indicios de un posible robo de tokens de cuentas de servicio aparecieron en el 22 % de los entornos cloud que observaron en 2025. El mismo informe advierte de que los clústeres mal configurados pueden funcionar con la auditoría desactivada. Sin ese registro, una investigación sobre quién leyó un secreto o quién se concedió permisos de administrador empieza sin su prueba principal.

La guía está escrita para equipos de plataforma y analistas de SOC de empresas medianas que operan clústeres gestionados en EKS, AKS o GKE, centralizan eventos en un SIEM y quieren saber qué ven, qué no ven y cuánto pagan por ello. Los nombres técnicos citados se han contrastado con la documentación oficial de Kubernetes, AWS, Microsoft y Google a 20 de noviembre de 2026.

¿Qué deja escrito el API server en cada petición?

Toda operación sobre un clúster pasa por el API server: el kubectl de un administrador, un despliegue desde la canalización de integración continua, un controlador que reconcilia recursos o el kubelet de un nodo que informa del estado de sus pods. El servidor autentica la petición, la autoriza con RBAC y, si hay una política de auditoría cargada, genera un evento. Según la documentación de Kubernetes, si el API server arranca sin el parámetro --audit-policy-file no se registra ningún evento; además necesita un destino configurado, sea un fichero de registro o un webhook.

Los campos que usará el analista

La referencia de la API de auditoría define el evento. Para detección importan siete campos: verb (el verbo de Kubernetes, como get, list, create o delete), user (la identidad autenticada, con sus grupos), impersonatedUser (presente si alguien actuó en nombre de otro) y objectRef (recurso, espacio de nombres, nombre y subrecurso). A ellos se suman sourceIPs, userAgent y annotations, donde el autorizador anota su decisión en authorization.k8s.io/decision con los valores allow o forbid. La tabla AKSAudit de Azure no tiene columna para impersonatedUser, así que en AKS la suplantación de identidades se controla mejor revisando quién tiene ese permiso en RBAC.

Dos de esos campos son poco fiables. La referencia avisa de que el userAgent lo declara el cliente y no debe creerse, y de que en sourceIPs todas las direcciones salvo la última pueden venir fijadas por quien hace la petición. Sirven para dar contexto a una alerta, pero una regla que se apoye solo en ellos se esquiva cambiando una cabecera.

Niveles de registro y orden de las reglas

La política de auditoría asigna a cada petición uno de cuatro niveles: None (no se registra), Metadata (quién, cuándo, qué recurso y qué verbo, sin cuerpos), Request (añade el cuerpo de la petición) y RequestResponse (añade también el de la respuesta). Cada evento puede emitirse en cuatro etapas: RequestReceived, ResponseStarted, ResponseComplete y Panic. Las reglas se evalúan en orden y la primera que coincide fija el nivel, así que una regla general colocada arriba anula las específicas de debajo.

En un clúster autogestionado ese fichero lo escribe el equipo de plataforma. En uno gestionado lo decide el proveedor, y ahí la detección empieza a divergir.

¿Qué decide el proveedor en un clúster gestionado?

Google publica su política de auditoría para GKE. Las escrituras (create, update, delete) se registran en general con nivel RequestResponse; las lecturas (get, list, watch), con Metadata; y las peticiones sobre secrets, configmaps y tokenreviews nunca pasan de Metadata, para no copiar su contenido al registro. AWS y Microsoft no publican la suya. Shay Berkovich, de Wiz, lo resumió en un análisis de noviembre de 2024: todos los proveedores que revisó salvo uno mantienen privado ese fichero, y GKE altera el formato del evento hasta el punto de que una regla escrita para Kubernetes estándar no le sirve sin adaptar.

La tabla resume qué hay que activar en cada caso y qué cuesta. Esa elección es la primera decisión de diseño, porque fija qué detecciones serán posibles después.

Registro de auditoría de Kubernetes en clústeres gestionados
ProveedorCómo se activaDestino y nombreEstado por defectoCoste y observaciones
Amazon EKSRegistro del plano de control, tipo audit (y authenticator, que muestra la correspondencia entre identidades de IAM y de Kubernetes)CloudWatch Logs, grupo /aws/eks/<clúster>/cluster, flujos kube-apiserver-audit-*DesactivadoIngesta y almacenamiento estándar de CloudWatch; la retención por defecto no caduca; entrega sin garantía
Azure AKSConfiguración de diagnóstico con la categoría kube-audit o kube-audit-admin, en modo específico del recursoLog Analytics, tablas AKSAudit y AKSAuditAdminSin destino hasta crear la configuraciónMicrosoft advierte de un coste considerable con kube-audit; AKSAuditAdmin excluye get y list
Google GKEAdmin Activity siempre activo; Data Access se activa en la configuración de auditoría del proyectoCloud Logging, registros cloudaudit.googleapis.com/activity y data_access, recurso k8s_clusterEscrituras registradas; lecturas desactivadasAdmin Activity sin coste; Data Access se factura según los precios de Cloud Logging

Elaboración de Hard2bit a partir de la documentación de AWS, Microsoft y Google consultada el 20 de noviembre de 2026. Los precios cambian por región y contrato; compruébelos antes de presupuestar.

La trampa del registro barato

AKS y GKE ofrecen una vía económica, y las dos recortan lo mismo: las lecturas. En AKS, la tabla AKSAuditAdmin contiene los eventos del API server salvo los de get y list, y Microsoft la recomienda en su guía de supervisión de AKS para contener el gasto. En GKE, según la política publicada, las peticiones get, list y updateStatus van al registro de Data Access, desactivado de serie. EKS no ofrece ese término medio: el tipo audit incluye lecturas, y es su volumen lo que encarece CloudWatch y lleva a desactivarlo.

Ese recorte deja a oscuras la técnica de acceso a credenciales más directa en un clúster: leer o listar secretos, que en la API es un get o un list. MITRE ATT&CK la cataloga como T1552.007, Container API, y suele ser el paso siguiente al robo de tokens de cuentas de servicio, del que Unit 42 vio indicios en uno de cada cinco entornos. Un clúster que solo registra escrituras verá al atacante cuando cree algo, pero no cuando lea las credenciales de la base de datos guardadas en un secreto.

El caso de kubectl exec

La detección de exec (T1609) tiene una trampa. Graham Helton publicó en enero de 2026 un evento de auditoría generado por kubectl 1.31 al ejecutar exec en un pod, y el verbo registrado era get, no create. El comentario del código de Kubernetes que cita lo explica: cuando el cliente usa WebSocket, el transporte que kubectl adoptó por defecto en la versión 1.31, la petición llega como GET y se traduce a get; con el protocolo antiguo, SPDY, llega como POST y se traduce a create.

Primera consecuencia: una regla que busque verb igual a create sobre el subrecurso exec no verá los exec de clientes modernos. Segunda, por deducción nuestra a partir de la documentación de Microsoft: esos eventos podrían no llegar a AKSAuditAdmin, que excluye get. En GKE la duda es menor, porque el ejemplo de Google sitúa los exec en el registro gratuito de Admin Activity. No lo damos por hecho; la prueba de validación descrita más abajo lo resuelve en cada clúster en unos diez minutos.

Helton señala además que, hasta Kubernetes 1.35, un rol con solo get sobre pods/exec permitía ejecutar comandos por WebSocket. La versión 1.35 exige también el permiso create mediante la función AuthorizePodWebsocketUpgradeCreatePermission, en beta y activa por defecto, que cubre exec, attach y port-forward; el evento sigue registrando get. En clústeres anteriores, o con esa función desactivada, hay que buscar los roles que conceden ese permiso.

¿Cómo se activa y se comprueba en cada plataforma?

Amazon EKS

Para un primer despliegue son suficientes los tipos audit y authenticator; el segundo registra cómo se autentica cada identidad de IAM ante el clúster. El cambio es asíncrono: hay que esperar a que la actualización termine y confirmar después que existe el flujo kube-apiserver-audit. Antes de fijar la retención, hay que revisar la que tiene hoy el grupo: si es indefinida y hay obligaciones de conservación, se exporta primero a S3 lo que vaya a quedar fuera. Con la nueva retención, CloudWatch marca los eventos más antiguos para su borrado y los elimina, normalmente en un plazo de 72 horas.

# Activa los registros audit y authenticator del plano de control.
aws eks update-cluster-config --name <clúster> --logging '{"clusterLogging":[{"types":["audit","authenticator"],"enabled":true}]}'
# Espera a que la actualización devuelva Successful.
aws eks describe-update --name <clúster> --update-id <id-de-la-actualización>
# Comprueba qué tipos quedan activos.
aws eks describe-cluster --name <clúster> --query "cluster.logging.clusterLogging"
# Confirma que llegan flujos de auditoría.
aws logs describe-log-streams --log-group-name /aws/eks/<clúster>/cluster --log-stream-name-prefix kube-apiserver-audit
# Retención de 365 días, tras revisar la actual.
aws logs put-retention-policy --log-group-name /aws/eks/<clúster>/cluster --retention-in-days 365

GuardDuty es un caso aparte. Según AWS, su protección para EKS analiza la auditoría sin necesidad de activar ni almacenar estos registros. Da hallazgos útiles, como Discovery:Kubernetes/SuccessfulAnonymousAccess cuando se aceptan peticiones del usuario system:anonymous, pero no deja el evento en bruto para investigar ni para reglas a medida. Complementa el registro; no lo sustituye.

Azure AKS

Microsoft recomienda el modo específico del recurso, que separa los eventos en tablas dedicadas en lugar de volcarlos en AzureDiagnostics. Hay que elegir entre kube-audit (tabla AKSAudit, con lecturas) y kube-audit-admin (AKSAuditAdmin, sin get ni list). La guía de supervisión de AKS sugiere una tercera vía: recoger kube-audit y configurar AKSAudit como tabla de registros básicos, más barata de ingerir a cambio de pagar por cada consulta y admitir solo alertas de registro simples. Antes de elegirla, hay que comprobar que esas alertas cubren las detecciones previstas, porque son más limitadas que las de una tabla analítica.

# Envía kube-audit-admin a Log Analytics en tablas específicas del recurso.
az monitor diagnostic-settings create --name aks-auditoria --resource <id-del-clúster> --workspace <id-del-área-de-trabajo> --export-to-resource-specific true --logs '[{"category":"kube-audit-admin","enabled":true}]'
# Comprueba la configuración de diagnóstico del clúster.
az monitor diagnostic-settings list --resource <id-del-clúster>

La verificación final se hace en Log Analytics: una consulta como AKSAuditAdmin | summarize count() by bin(TimeGenerated, 1h) debe devolver eventos cada hora. Si la tabla aparece vacía tras media hora, revise que el área de trabajo es la correcta y que la configuración se creó en modo específico del recurso. Microsoft avisa de que la CLI no comprueba el estado de aprovisionamiento del clúster, así que hay que confirmar el resultado y no darlo por hecho.

Google GKE

En GKE las escrituras se registran sin activar ninguna opción. Las lecturas exigen habilitar los registros de Data Access para la API de Kubernetes Engine en la configuración de registros de auditoría del proyecto, con los subtipos ADMIN_READ y DATA_READ. La documentación de Google advierte de que esos registros se facturan y permite excluirlos con un receptor si el volumen supera la cuota. La comprobación se hace con gcloud.

# Últimos eventos de escritura del clúster en Admin Activity.
gcloud logging read 'resource.type="k8s_cluster" AND logName:"cloudaudit.googleapis.com%2Factivity"' --limit 5
# Últimos eventos de lectura, si Data Access está activo.
gcloud logging read 'resource.type="k8s_cluster" AND logName:"cloudaudit.googleapis.com%2Fdata_access"' --limit 5

¿Qué detecciones justifican el coste del registro?

Activar la auditoría sin reglas encima solo sirve para la investigación posterior. Proponemos cinco comportamientos con los que empezar, elegidos porque aparecen en la matriz de contenedores de MITRE ATT&CK y porque se ven bien en el API server. Las consultas KQL están escritas para AKS; la regla Sigma y las búsquedas de CloudWatch y Cloud Logging cubren las otras plataformas. En todas, el primer paso es medir la línea base durante una o dos semanas antes de convertirlas en alertas.

Cinco comportamientos que vigilar en la auditoría de Kubernetes
ComportamientoTécnica ATT&CKCampos claveNecesita lecturas
Exec o attach en un podT1609objectRef.subresource exec o attachEn AKS, sí, si el cliente usa WebSocket
Lectura o listado de secretos por una cuenta de servicioT1552.007objectRef.resource secrets, verb get, list o watchSí
Cambios en RBAC (roles y vinculaciones)T1098.006objectRef.resource clusterrolebindings, rolebindings, clusterroles, rolesNo
Peticiones aceptadas a system:anonymousT1078user.username system:anonymous, decisión allowSí
Ráfaga de peticiones denegadas de una misma identidad u origenT1613responseStatus.code 401 o 403Sí

Técnicas según MITRE ATT&CK for Containers. La columna de lecturas indica si la detección exige registrar get y list.

Ejecución en contenedores

La consulta no filtra por verbo, por el motivo explicado antes, y cuenta identificadores de auditoría distintos porque las peticiones largas como exec generan un evento al empezar la respuesta y otro al terminarla. Agrupa por identidad, pod y cliente para que el analista distinga el exec puntual de un administrador de guardia del de una cuenta de servicio que nunca lo había hecho.

// Exec y attach en pods durante los últimos siete días.
// AKSAudit incluye también los exec registrados como get.
AKSAudit
| where TimeGenerated > ago(7d)
| where tostring(ObjectRef.subresource) in ("exec", "attach")
// La etapa RequestReceived aún no lleva la decisión de autorización.
| where Stage != "RequestReceived"
// Campos útiles para el analista.
| extend usuario = tostring(User.username), ns = tostring(ObjectRef.namespace), pod = tostring(ObjectRef.name), decision = tostring(Annotations["authorization.k8s.io/decision"])
// Agrupa por identidad y cliente.
| summarize peticiones = dcount(AuditId), primera = min(TimeGenerated), ultima = max(TimeGenerated) by usuario, ns, pod, decision, UserAgent
| order by ultima desc

Falsos positivos esperables: herramientas de depuración del equipo de plataforma, operadores que ejecutan comandos de mantenimiento en bases de datos y algunas canalizaciones de despliegue. Las cuentas de servicio que hacen exec deberían ser pocas y conocidas; las demás requieren revisión. Para EKS, la misma búsqueda en CloudWatch Logs Insights:

# CloudWatch Logs Insights sobre el grupo /aws/eks/<clúster>/cluster.
fields @timestamp, user.username, objectRef.namespace, objectRef.name, verb, userAgent
| filter @logStream like /kube-apiserver-audit/
| filter objectRef.subresource = "exec" or objectRef.subresource = "attach"
| sort @timestamp desc
| limit 200

En GKE, el filtro equivalente en el Explorador de registros es resource.type="k8s_cluster" con protoPayload.methodName=~"io.k8s.core.v1.pods.(exec|attach)". Google usa un formato de evento distinto, y por eso los campos no se llaman igual que en Kubernetes estándar. Según la documentación de auditoría de GKE, los exec aparecen en Admin Activity con la etiqueta command.gke.io/command, que recoge el comando. La prueba de validación permite confirmar si los exec por WebSocket llegan también a ese registro.

Lectura de secretos por cuentas de servicio

Esta detección solo funciona con lecturas registradas, es decir, con AKSAudit, Data Access en GKE o el tipo audit en EKS. Se centra en cuentas de servicio porque son la identidad que queda en manos del atacante cuando roba un token desde un pod. Los kubelet de los nodos leen secretos de forma continua para montarlos en los pods, así que se excluyen.

// Cuentas de servicio que listan secretos de todo el clúster, leen en varios espacios de nombres o reciben denegaciones.
AKSAudit
| where TimeGenerated > ago(1d)
| where tostring(ObjectRef.resource) == "secrets" and Verb in ("get", "list", "watch")
// Campos útiles para el analista.
| extend usuario = tostring(User.username), ns = tostring(ObjectRef.namespace), decision = tostring(Annotations["authorization.k8s.io/decision"])
| where usuario startswith "system:serviceaccount:"
// Agrupa por identidad y cliente.
| summarize lecturas = dcount(AuditId), espacios = dcount(ns), globales = countif(isempty(ns)), denegadas = countif(decision == "forbid") by usuario, UserAgent
// Umbral de alerta.
| where espacios > 1 or globales > 0 or denegadas > 0
// Umbrales por ajustar con la línea base.

Los falsos positivos más habituales son controladores que gestionan secretos por diseño (cert-manager, external-secrets o sealed-secrets), Helm, que guarda el estado de cada versión desplegada en secretos, y los agentes de copias de seguridad del clúster. La regla relacionada de Elastic nombra esos controladores y Helm en su guía de investigación y recomienda excluir sus cuentas de servicio, aunque su consulta exime los grupos de cuentas de servicio de varios espacios de nombres enteros. Aquí se recomienda excluir solo cuentas de servicio individuales, porque un espacio de nombres exento es un buen sitio donde esconderse.

Cambios en RBAC y peticiones de tokens

La tercera consulta reúne operaciones poco frecuentes que dan o fabrican privilegios: crear o modificar roles y vinculaciones, aprobar solicitudes de firma de certificados y pedir tokens para cuentas de servicio. La guía de buenas prácticas de RBAC de GKE señala los verbos escalate y bind y la creación de solicitudes de certificado entre los riesgos de escalada de privilegios.

// Operaciones que conceden o fabrican privilegios, último día.
AKSAuditAdmin
| where TimeGenerated > ago(1d)
// Campos útiles para el analista.
| extend usuario = tostring(User.username), recurso = tostring(ObjectRef.resource), sub = tostring(ObjectRef.subresource), decision = tostring(Annotations["authorization.k8s.io/decision"])
// Tres condiciones alternativas.
| where (recurso in ("clusterrolebindings", "rolebindings", "clusterroles", "roles") and Verb in ("create", "update", "patch", "delete"))
or (recurso == "certificatesigningrequests" and sub == "approval")
or (recurso == "serviceaccounts" and sub == "token" and not(usuario startswith "system:node:"))
// Columnas de salida.
| project TimeGenerated, usuario, Verb, recurso, sub, nombre = tostring(ObjectRef.name), decision, SourceIps

Aquí el ruido viene de las actualizaciones de la plataforma, de los operadores que instalan roles al desplegarse y de las herramientas de GitOps (Argo CD, Flux) que aplican manifiestos con RBAC. Correlacionar con la ventana de despliegue de la canalización reduce mucho el volumen. Lo que debería saltar siempre es una vinculación nueva creada por una identidad humana fuera de esa ventana, o por una cuenta de servicio que no sea la del despliegue.

El cuarto comportamiento, el acceso anónimo, necesita la tabla completa, porque el abuso habitual son lecturas. También hay que descartar las rutas de salud y versión, que Kubernetes permite consultar sin autenticar y que inundarían la alerta; por eso la consulta se queda solo con las peticiones que tienen recurso.

// Peticiones aceptadas sin autenticar sobre recursos de la API.
AKSAudit
| where TimeGenerated > ago(1d)
// Usuario anónimo o grupo de no autenticados.
| where tostring(User.username) == "system:anonymous" or tostring(User.groups) has "system:unauthenticated"
| where tostring(Annotations["authorization.k8s.io/decision"]) == "allow" and isnotempty(tostring(ObjectRef.resource))
// Columnas de salida.
| project TimeGenerated, Verb, recurso = tostring(ObjectRef.resource), RequestUri, SourceIps

La última consulta cubre la ráfaga de denegaciones, que suele indicar que alguien prueba qué permite un token recién robado. Una identidad legítima conoce sus permisos y pocas veces falla en serie; una que recorre recursos sin conocerlos acumula respuestas 401 y 403 en pocos minutos.

// Más de 20 respuestas 401 o 403 en diez minutos por identidad u origen.
AKSAudit
| where TimeGenerated > ago(1d)
| where toint(ResponseStatus.code) in (401, 403)
// Recuento por identidad, origen y ventana.
// En los 401 el usuario llega vacío y cuenta el origen.
| summarize fallos = dcount(AuditId), recursos = dcount(tostring(ObjectRef.resource)) by usuario = tostring(User.username), origen = tostring(SourceIps), bin(TimeGenerated, 10m)
// Umbral inicial.
| where fallos > 20

El umbral de 20 es un punto de partida, no una cifra validada, y se ajusta con la línea base. Usa AKSAudit porque el sondeo típico son lecturas, y filtra por código de respuesta porque los fallos de autenticación (401), como un token caducado o robado y ya revocado, no llevan anotación de autorización.

Tampoco identifican al usuario, porque el API server los registra antes de resolver la identidad: los 401 se agrupan solo por origen, y la atribución a una identidad vale para los 403. Suelen hacer ruido los controladores mal configurados tras una actualización, que fallan en bucle contra el mismo recurso; el recuento de recursos distintos ayuda a separarlos.

Una regla Sigma portable

Para un SIEM que no sea Sentinel, la regla Sigma siguiente cubre la ejecución en contenedores con los campos del evento estándar de Kubernetes. Sirve directamente para EKS y para clústeres autogestionados; para GKE hay que traducir los campos a su formato.

title: Exec o attach en un pod de Kubernetes
id: 0663fb10-35df-478d-9401-4a343865af80
status: experimental
description: Detecta peticiones al subrecurso exec o attach de un pod sin filtrar por verbo, para cubrir clientes con WebSocket y con SPDY.
author: Hard2bit
date: 2026-11-20
tags: [attack.execution, attack.t1609]
logsource: {category: application, product: kubernetes, service: audit}
detection: {selection: {objectRef.resource: pods, objectRef.subresource: [exec, attach]}, condition: selection}
falsepositives: [Depuración por el equipo de plataforma, Operadores con tareas de mantenimiento]
level: medium

SigmaHQ mantiene además reglas públicas para el mismo origen, como la de enumeración de secretos, que busca el verbo list sobre secrets. Antes de convertir una regla, sigma check valida la sintaxis, y además hay que comprobar que los nombres de campo coinciden con los que entrega el conector.

Validación segura

La validación no necesita herramientas ofensivas. Con autorización por escrito y aviso previo al SOC, dos espacios de nombres de prueba y una cuenta de servicio dedicada son suficientes para generar los comportamientos anteriores y medir cuánto tardan en llegar al SIEM. EKS entrega los registros sin garantía de inmediatez, y la latencia efectiva hay que medirla antes de prometer tiempos de respuesta. Para la lectura de secretos no sirve suplantar a la cuenta con --as: el evento guardaría como usuario al operador que suplanta, y la consulta no lo vería.

# Espacios de nombres, pod y cuenta de servicio de prueba.
kubectl create namespace pruebas-soc-a
kubectl create namespace pruebas-soc-b
kubectl -n pruebas-soc-a run prueba --image=busybox:1.36 --restart=Never -- sleep 3600
kubectl -n pruebas-soc-a wait --for=condition=Ready pod/prueba --timeout=90s
kubectl -n pruebas-soc-a create serviceaccount lector-prueba
# Exec benigno: debe aparecer en la primera consulta.
kubectl -n pruebas-soc-a exec prueba -- id
# Secretos de prueba y permiso de lectura en los dos espacios.
kubectl -n pruebas-soc-a create secret generic prueba-deteccion --from-literal=clave=valor-de-prueba
kubectl -n pruebas-soc-b create secret generic prueba-deteccion --from-literal=clave=valor-de-prueba
kubectl -n pruebas-soc-a create rolebinding lector --clusterrole=view --serviceaccount=pruebas-soc-a:lector-prueba
kubectl -n pruebas-soc-b create role lector --verb=get --resource=secrets
kubectl -n pruebas-soc-b create rolebinding lector --role=lector --serviceaccount=pruebas-soc-a:lector-prueba

# Token de diez minutos para la cuenta de prueba.
TOKEN=$(kubectl -n pruebas-soc-a create token lector-prueba --duration=10m)
# Lecturas con la identidad de la cuenta: deben aparecer en la segunda consulta.
kubectl --token="$TOKEN" -n pruebas-soc-b get secret prueba-deteccion
kubectl --token="$TOKEN" -n pruebas-soc-a get secret prueba-deteccion
# Limpieza al terminar.
kubectl delete namespace pruebas-soc-a pruebas-soc-b

La lectura en pruebas-soc-a fallará con un 403, porque el rol view no incluye secretos, y esa denegación también debe verse en la consulta. Según cómo autentique el kubeconfig (por ejemplo, con un complemento de AWS o de Azure), puede requerirse un contexto aparte para usar el token.

El resultado del exec es el que más información da: si el evento aparece en AKSAudit con verbo get y no aparece en AKSAuditAdmin, la configuración actual no ve los exec de los kubectl modernos, y hay que decidir si se paga la tabla completa o se acepta el hueco por escrito. Fecha, clúster, versión de kubectl, tabla y latencia deben quedar anotados; ese registro sirve también como evidencia para la auditoría.

¿Dónde falla la auditoría del API server?

El registro ve peticiones a la API, no lo que pasa dentro de un contenedor. Tras un exec, los comandos que el atacante teclee en la sesión interactiva no quedan en el evento; solo el comando inicial, que viaja en requestURI. Para ver la actividad de procesos se necesita un sensor de ejecución en los nodos, sea de la plataforma cloud o de un tercero, y correlacionar ambas fuentes.

Tampoco ve lo que no pasa por el API server. Helton documentó que incluso el permiso get sobre nodes/proxy permite ejecutar comandos a través del kubelet, y que esa vía no deja rastro en la auditoría del clúster más allá de una consulta de autorización. El equipo de seguridad de Kubernetes lo considera comportamiento previsto.

Desde la versión 1.36 es estable la autorización granular de la API del kubelet, que permite dar a los agentes de monitorización permisos más específicos (métricas, registros o estado de los pods) y retirarles nodes/proxy. No ofrece sustituto para exec, attach o port-forward a través del kubelet, así que los agentes que los usen seguirán necesitándolo. Las medidas defensivas son tres: revisar qué roles conceden nodes/proxy, migrar esos agentes a los permisos granulares y limitar por red el acceso al puerto del kubelet a lo imprescindible.

Otros límites que deben tenerse presentes al diseñar la cobertura:

  • El formato de GKE difiere del estándar, así que cada regla necesita su versión para Google.
  • Los niveles los fija el proveedor. AKSAudit tiene columnas para el cuerpo de la petición y de la respuesta, pero qué peticiones lo llevan depende de la política del proveedor, y AWS avisa en su guía de buenas prácticas de EKS de que las entradas de más de 1 MB se recortan o se quedan solo con los metadatos de la petición. Antes de construir una regla sobre el cuerpo (por ejemplo, para ver si un pod se creó como privilegiado), hay que comprobar en un evento registrado que el dato está.
  • La entrega no es inmediata y, en EKS, no está garantizada. Una alerta crítica no debería depender de un único evento.
  • En EKS, el registro authenticator ayuda a relacionar la identidad de Kubernetes con el rol de IAM que la originó.

Ninguno de estos límites resta valor al registro; marcan dónde termina y por qué se combina con un sensor de ejecución y con mínimo privilegio en RBAC.

Evidencias para auditoría

Un registro que se conserva y se revisa cubre controles presentes en los principales marcos de cumplimiento. La tabla no sustituye al análisis de aplicabilidad de cada organización; indica qué evidencia aporta cada pieza de esta guía.

Correspondencia orientativa con marcos de cumplimiento
MarcoControlEvidencia que aporta esta guía
ENS (RD 311/2022)op.exp.8 Registro de la actividad; op.mon.1 Detección de intrusiónConfiguración de auditoría por clúster, retención fijada y reglas activas
ISO/IEC 27001:2022A.8.15 Registro; A.8.16 Actividades de seguimiento; A.8.2 Derechos de acceso privilegiadoRegistros del API server, consultas de detección y revisión de cambios en RBAC
NIS2 (Directiva 2022/2555)Art. 21.2 b) gestión de incidentes; art. 21.2 i) políticas de control de accesoCapacidad de reconstruir quién hizo qué en el clúster y alertas sobre privilegios
DORA (Reglamento 2022/2554)Art. 10 DetecciónMecanismos de detección de actividad anómala sobre la plataforma de contenedores

Correspondencia elaborada por Hard2bit con carácter orientativo. La aplicabilidad depende del alcance de cada organización.

Por dónde empezar

El primer paso es activar el registro con lecturas incluidas en el clúster que guarde los secretos más valiosos, aunque sea solo ese y con una retención corta, y poner encima la consulta de lectura de secretos por cuentas de servicio. El resto de la guía se puede construir después sobre esa base.

Después, la prueba del exec en un espacio de nombres de laboratorio dirá si la configuración que se paga ve lo que se cree que ve. Para la línea base, el ajuste de falsos positivos o la vigilancia continua, nuestro SOC gestionado y el servicio de búsqueda proactiva de amenazas (threat hunting) trabajan con estas mismas fuentes. La revisión de IAM y postura cloud cubre el lado de RBAC y de las identidades de los proveedores.

Este análisis enlaza con otros del blog: qué registros enviar al SIEM y con qué retención, cómo medir la robustez de una detección frente a ATT&CK y cómo proteger las cuentas de servicio y sus tokens, que son la otra mitad de este problema. Si el clúster se despliega desde GitHub, la guía de seguridad de GitHub Actions cubre la canalización que tiene permisos sobre él.

Fuentes y metodología: documentación oficial de Kubernetes (auditoría y referencia de la API audit.k8s.io/v1), Amazon EKS y GuardDuty, Azure Monitor y AKS, y Google Kubernetes Engine y Cloud Logging; MITRE ATT&CK; informe de Unit 42 de abril de 2026; análisis de Wiz y de Graham Helton; reglas públicas de Elastic y SigmaHQ. Información contrastada a 20 de noviembre de 2026.
Aviso: las consultas y configuraciones de esta guía son orientativas. Los productos gestionados cambian con frecuencia: cada cambio debe validarse en un entorno de pruebas y su impacto en el coste y en la retención de datos debe revisarse antes de activarlo en producción. Las reglas deben ajustarse a la línea base de cada clúster. Las pruebas de validación deben contar con autorización por escrito.

Preguntas frecuentes

¿Está activado por defecto el registro de auditoría de Kubernetes en EKS, AKS y GKE? ▾

No del todo. En EKS cada tipo de registro del plano de control está desactivado hasta que se activa. En AKS no llega a ningún destino hasta crear una configuración de diagnóstico con kube-audit o kube-audit-admin. En GKE se registran siempre las escrituras (Admin Activity) sin coste, pero las lecturas (get, list) van a Data Access, que está desactivado y se factura.

¿En qué se distinguen AKSAudit y AKSAuditAdmin? ▾

AKSAudit recoge todos los eventos del API server; AKSAuditAdmin, los mismos salvo los de los verbos get y list. AKSAuditAdmin es considerablemente más barata, pero pierde la lectura de secretos y, si el cliente usa WebSocket, puede perder también los exec en pods, que se registran como get. La forma de comprobarlo en un clúster es hacer un exec de prueba y buscarlo en ambas tablas.

¿Por qué una regla de detección de kubectl exec no se activa? ▾

Probablemente filtra por el verbo create. Los kubectl recientes que usan WebSocket generan un GET que el API server registra como get; solo el protocolo SPDY antiguo produce create. La solución es filtrar por el subrecurso exec o attach sin condición de verbo y comprobar que la tabla o el registro consultado incluye lecturas.

¿Se puede cambiar la política de auditoría en un clúster gestionado? ▾

En EKS y AKS no: el proveedor decide qué se registra y con qué nivel, y no publica el fichero. Google sí publica la política de GKE, que registra las escrituras con cuerpo completo y las peticiones sobre secrets, configmaps y tokenreviews solo con metadatos. Lo que sí controla el cliente es qué tipos o categorías activa, a dónde se envían y cuánto tiempo se conservan.

¿Sustituye GuardDuty al registro de auditoría en EKS? ▾

Es una capa útil, pero no sustituye al registro. GuardDuty analiza la auditoría de EKS sin que haya que almacenarla y genera hallazgos, aunque no deja el evento en bruto para investigar ni para escribir reglas a medida. Para reconstruir un incidente o adaptar detecciones al entorno se necesita el registro en un sitio donde se pueda consultar.

¿Qué no ve la auditoría del API server? ▾

No ve lo que ocurre dentro del contenedor después de un exec, salvo el comando inicial, ni la ejecución de comandos a través del kubelet con el permiso nodes/proxy, que no pasa por el API server. Por eso se complementa con un sensor de ejecución en los nodos, con la revisión de quién tiene ese permiso y con reglas de red que limiten el acceso al puerto del kubelet.

¿Cuánto tiempo deben conservarse los registros de auditoría de Kubernetes? ▾

Depende del marco aplicable y del análisis de riesgo, pero debe fijarse de forma explícita: en EKS la retención por defecto de CloudWatch no caduca y acumula coste, y en GKE y AKS depende de la configuración del destino. Una práctica habitual es conservar en caliente lo que usan las reglas y archivar el resto en almacenamiento más barato para investigaciones.

Comparte este artículo

Cita este artículo

Si escribes sobre este tema, puedes citarlo así:

Daniel O'Grady (20 de noviembre de 2026). Qué registra el API server de Kubernetes y cómo convertirlo en detección en EKS, AKS y GKE. Hard2bit. https://hard2bit.com/blog/registro-auditoria-kubernetes-api-server-eks-aks-gke-deteccion/

<a href="https://hard2bit.com/blog/registro-auditoria-kubernetes-api-server-eks-aks-gke-deteccion/">Qué registra el API server de Kubernetes y cómo convertirlo en detección en EKS, AKS y GKE</a> (Hard2bit)

¿Necesitas saber qué te aplica, por dónde empezar y cuánto cuesta?

Es la pregunta con la que empieza casi cualquier proyecto. La resolvemos en una reunión de 30 minutos con un consultor técnico, no con un comercial: sales con el alcance acotado, las prioridades ordenadas por riesgo y una horquilla de precio. Con la información de esa reunión, la convertimos en propuesta cerrada. Pentesting, auditoría de ciberseguridad, Microsoft 365, SOC/MDR y cumplimiento (ENS, ISO 27001, NIS2, DORA).

Si tu situación es distinta, plantéanosla igualmente: también atendemos consultas puntuales de ciberseguridad y cumplimiento normativo.

Empresa española de ciberseguridad · ENS categoría ALTA · ISO 27001 · Normalmente respondemos en menos de 24h laborables