mTLS con cert-manager y CA interna en Kubernetes para servicios internos
La necesidad de mTLS en entornos Kubernetes
En cualquier clúster de Kubernetes que maneje datos sensibles o que siga principios de zero-trust, la autenticación mutua TLS (mTLS) deja de ser una opción y se convierte en un requisito. Mientras que el TLS estándar solo autentica al servidor, mTLS exige que ambas partes presenten certificados válidos, lo que garantiza que tanto el cliente como el servidor son quienes dicen ser. Esto es crítico cuando los microservicios internos se comunican entre sí a través de la red del clúster, donde un pod comprometido podría intentar suplantar a otro servicio para acceder a datos restringidos.
Implementar mTLS de forma manual es una pesadilla operativa: generar certificados, distribuirlos, renovarlos y revocarlos requiere un sistema robusto. Kubernetes no proporciona esta funcionalidad de forma nativa. Aquí es donde entra cert-manager, un operador que automatiza la emisión y renovación de certificados dentro del clúster. Combinado con una Autoridad Certificadora (CA) interna, cert-manager se convierte en el pilar para habilitar mTLS sin fricción.
En este artículo exploraremos, desde una perspectiva de administración de sistemas, cómo configurar una CA interna, emitir certificados para servicios y forzar mTLS en una comunicación típica entre dos pods. No nos limitaremos a un tutorial paso a paso; analizaremos la arquitectura, los recursos involucrados y los puntos de fallo más comunes.
Arquitectura de confianza: CA interna vs CA pública
Una CA interna (o privada) es una entidad emisora que solo es confiable dentro de nuestro ecosistema. A diferencia de una CA pública (como Let's Encrypt), no está incluida en los almacenes de confianza de navegadores o sistemas operativos externos. Esta característica es precisamente su ventaja para tráfico interno: no necesitamos que terceros validen nuestros certificados, y podemos emitir certificados con cualquier nombre DNS o IP que corresponda a los servicios internos del clúster.
Emitir certificados con una CA pública para servicios internos es posible, pero problemático: las CA públicas validan el dominio, y los servicios internos no suelen tener FQDNs accesibles desde el exterior. Además, la revocación y el control de la cadena de confianza quedan fuera de nuestras manos. Con una CA interna, retenemos el control total de la política de emisión y rotación.
cert-manager soporta la creación de una CA autofirmada mediante el recurso Issuer o ClusterIssuer de tipo CA. La diferencia clave: un Issuer es específico de un namespace, mientras que un ClusterIssuer es global. Para una CA corporativa que autentica servicios internos a través de múltiples namespaces, la elección correcta es un ClusterIssuer.
Instalación de cert-manager
El primer paso es instalar cert-manager en el clúster. La forma más común es mediante el manifiesto YAML oficial o con Helm. Desde una perspectiva de administración, Helm ofrece más control sobre las versiones y la personalización. Ejemplo de instalación con Helm:
helm repo add jetstack https://charts.jetstack.io
helm repo update
helm install cert-manager jetstack/cert-manager \
--namespace cert-manager \
--create-namespace \
--set installCRDs=true
El flag installCRDs=true es crucial, ya que instala los Custom Resource Definitions (CRDs) que cert-manager necesita. Una vez instalado, verificamos que los pods estén corriendo:
kubectl get pods -n cert-manager
Deberíamos ver tres pods: cert-manager, cert-manager-cainjector y cert-manager-webhook. El webhook es vital para validar las solicitudes de certificados y evitar configuraciones incorrectas.
Creación de la Autoridad Certificadora interna
Para crear nuestra CA interna, primero generamos un par de llaves y un certificado autofirmado. Podemos hacerlo con openssl directamente, pero cert-manager también permite hacerlo a través de un recurso Certificate que actúa como autofirmado. La opción más limpia para administradores es generar el certificado CA fuera del clúster y luego importarlo como un secreto. Esto nos permite mantener la llave privada de la CA en un lugar seguro y controlado, sin exponerla en el clúster más de lo necesario.
Generamos la CA con openssl:
openssl genrsa -out ca.key 4096
openssl req -x509 -new -nodes -key ca.key -sha256 -days 3650 \
-subj "/CN=Internal-CA/O=MyOrg" \
-out ca.crt
El valor -days 3650 define una vida útil de 10 años para la CA. Para una CA interna, este período es razonable, aunque algunas organizaciones prefieren renovarla cada 5 años. Lo importante es que la rotación de la CA no debe confundirse con la rotación de certificados de servicio, que será mucho más frecuente.
Ahora creamos el namespace donde residirá la CA y el secreto con la llave y el certificado:
kubectl create namespace cert-manager
kubectl create secret tls ca-key-pair \
--cert=ca.crt --key=ca.key \
--namespace=cert-manager
Con el secreto en su lugar, definimos un ClusterIssuer que referencie a este secreto:
apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
name: internal-ca-issuer
spec:
ca:
secretName: ca-key-pair
Este ClusterIssuer es el punto central desde el cual cert-manager emitirá todos los certificados firmados por nuestra CA interna. Aplicamos el manifiesto con:
kubectl apply -f cluster-issuer.yaml
Emisión de certificados para servicios individuales
Una vez que el ClusterIssuer está listo, podemos solicitar certificados para cada servicio. En un caso típico, tendremos dos pods: un cliente (por ejemplo, un frontend) y un servidor (por ejemplo, una API). Cada uno necesita un certificado con su propio Common Name (CN) y, opcionalmente, con Subject Alternative Names (SANs) que coincidan con su nombre de servicio DNS en el clúster.
Definimos un recurso Certificate para el servidor:
apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
name: api-svc-cert
namespace: production
spec:
secretName: api-svc-tls
duration: 2160h # 90 días
renewBefore: 360h # 15 días antes de expirar
commonName: api-svc
dnsNames:
- api-svc.production.svc.cluster.local
issuerRef:
name: internal-ca-issuer
kind: ClusterIssuer
Cuando aplicamos este recurso, cert-manager automáticamente genera una llave privada, crea una solicitud de firma (CSR) y la envía al ClusterIssuer. El resultado se almacena en el secreto api-svc-tls dentro del namespace production. El secreto contendrá las claves tls.crt y tls.key, listas para ser montadas en el pod.
Para el cliente, el proceso es idéntico. Sin embargo, en mTLS el cliente debe presentar un certificado firmado por la misma CA que el servidor confía. Esto significa que ambos comparten la misma cadena de confianza, y el servidor validará el certificado del cliente contra el certificado CA que configuremos en su truststore.
Configuración del servidor para exigir mTLS
La configuración del servidor depende del stack tecnológico que estemos usando. Si es un servidor HTTP con Nginx Ingress o un proxy como Envoy, la configuración varía. Para un servicio interno que no pasa por el Ingress, lo más común es montar los certificados como volúmenes y configurar el servidor web para requerir y validar el certificado del cliente.
Por ejemplo, para un pod que corre Nginx, montamos el secreto del certificado y el certificado CA. Al montar el secreto, Kubernetes crea los archivos en el sistema de archivos del contenedor. Definimos un volumen en el pod:
volumes:
- name: tls-certs
secret:
secretName: api-svc-tls
- name: ca-certs
secret:
secretName: ca-key-pair
Luego, en la configuración del servidor Nginx, activamos la verificación del certificado del cliente:
server {
listen 8443 ssl;
ssl_certificate /etc/tls/tls.crt;
ssl_certificate_key /etc/tls/tls.key;
ssl_client_certificate /etc/ca/ca.crt;
ssl_verify_client on;
ssl_verify_depth 1;
location / {
proxy_pass http://backend-service:8080;
}
}
La directiva ssl_verify_client on fuerza la ver
comentarios(0)
$ dejar comentario