Automatización de rotación y renovación de certificados TLS internos con ACME, Vault y Bash
Introducción
Los certificados TLS internos garantizan la confidencialidad e integridad de la comunicación entre servicios en infraestructuras híbridas. La renovación manual es propensa a errores y rompe la disponibilidad. En este artículo describimos cómo combinar ACME (Automated Certificate Management Environment), HashiCorp Vault y scripts Bash para crear una cadena de automatización que funcione tanto en datacenters on‑prem como en proveedores cloud (AWS, Azure, GCP).
Al final tendrás:
- Un issuer ACME interno en Vault.
- Políticas de Vault que limitan la emisión a dominios internos.
- Un script Bash que solicita, almacena y despliega certificados.
- Un proceso de cron o systemd timer que ejecuta la rotación automáticamente.
Requisitos previos
Infraestructura
- Servidor Vault (
v1.13+) con alta disponibilidad (Raft o Consul). - Acceso a un endpoint ACME público (ej.
https://acme-v02.api.letsencrypt.org/directory) o a un CA interno que exponga la API ACME (ej.step-ca). - DNS interno que resuelva los nombres de los servicios (puede ser Bind, CoreDNS, o Route53).
- Máquinas cliente con Bash 4+,
curl,jqyopensslinstalados.
Credenciales
Necesitarás:
- Token de root o un token con policy
acme_issuerpara crear el emisor. - Token con policy
cert_renewque permitawriteenacme/issue/*.
Configuración de Vault como emisor ACME
1. Habilitar el motor de secretos PKI
# En la consola de Vault
vault secrets enable -path=internal-pki pki
# Configuramos un máximo de 10 años (3650 días)
vault secrets tune -max-lease-ttl=87600h internal-pki
2. Generar la CA raíz interna
vault write -format=json internal-pki/root/generate/internal \ common_name="MyInternal CA" \ ttl=87600h > ca.jsonExportamos el certificado y la clave para el servidor ACME
jq -r ‘.data.certificate’ ca.json > /etc/vault.d/ca.crt jq -r ‘.data.private_key’ ca.json > /etc/vault.d/ca.key chmod 600 /etc/vault.d/ca.key
3. Configurar el endpoint ACME en Vault
Vault incluye un plugin acme a partir de la versión 1.12. Lo habilitamos y lo configuramos:
# Habilitar el plugin vault secrets enable -path=acme acmeRegistrar el plugin (si no está en el binario)
vault write sys/plugins/catalog/acme
sha_256=$(sha256sum /usr/local/lib/vault/plugins/vault-plugin-acme | cut -d’ ’ -f1)
command=“vault-plugin-acme”Configurar el emisor
vault write acme/config/issuer/internal
ca_bundle=@/etc/vault.d/ca.crt
ca_private_key=@/etc/vault.d/ca.key
name=“internal-ca”
ttl=“720h”
4. Definir políticas de emisión
# policy: acme_issuer.hcl path "acme/issue/*" { capabilities = ["create", "read"] }policy: cert_renew.hcl
path “acme/issue/internal/*” { capabilities = [“create”, “read”] }
Aplicamos las políticas:
vault policy write acme_issuer acme_issuer.hcl
vault policy write cert_renew cert_renew.hcl
Script Bash para solicitar y desplegar certificados
2.1. Estructura del script
El script renew_cert.sh realiza:
- Generación de una clave RSA/ECDSA.
- Creación de un CSR con los SAN necesarios.
- Solicitud al endpoint ACME de Vault.
- Almacenamiento del certificado y clave en
/etc/ssl/privatey recarga del servicio.
2.2. Código completo
#!/usr/bin/env bash set -euo pipefail#---- Configuración ------------------------------------------------- VAULT_ADDR=“https://vault.internal:8200” VAULT_TOKEN=“s.xxxxxxx” # token con policy cert_renew ACME_ISSUER=“internal” DOMAIN=”${1:-myservice.internal}” # argumento: nombre DNS CERT_DIR=“/etc/ssl/private/${DOMAIN}” KEY_ALGO=“rsa” # o “ecdsa” RSA_BITS=4096 ECDSA_CURVE=“prime256v1” #-------------------------------------------------------------------
mkdir -p ”${CERT_DIR}” cd ”${CERT_DIR}”
1) Generar clave privada
if [[ ”${KEY_ALGO}” == “rsa” ]]; then openssl genpkey -algorithm RSA -pkeyopt rsa_keygen_bits:${RSA_BITS} -out priv.key else openssl genpkey -algorithm EC -pkeyopt ec_paramgen_curve:${ECDSA_CURVE} -out priv.key fi chmod 600 priv.key
2) Crear CSR (incluye SAN)
cat > csr.conf <<EOF [ req ] distinguished_name = req_distinguished_name req_extensions = v3_req prompt = no
[ req_distinguished_name ] CN = ${DOMAIN}
[ v3_req ] subjectAltName = @alt_names
[ alt_names ] DNS.1 = ${DOMAIN} DNS.2 = ${DOMAIN//./-}.svc.cluster.local # ejemplo para k8s EOF
openssl req -new -key priv.key -config csr.conf -out request.csr
3) Solicitar certificado vía ACME de Vault
RESPONSE=$(curl -s —header “X-Vault-Token: ${VAULT_TOKEN}”
—request POST
—data @- ”${VAULT_ADDR}/v1/acme/issue/${ACME_ISSUER}/${DOMAIN}” <<EOF { “csr”: ”$(base64 -w0 request.csr)” } EOF )4) Parsear respuesta
CERT=$(echo ”${RESPONSE}” | jq -r ‘.data.certificate’) CHAIN=$(echo ”${RESPONSE}” | jq -r ‘.data.issuer_certificate’) FULLCHAIN=”${CERT}\n${CHAIN}”
Guardar
echo -e ”${CERT}” > cert.crt echo -e ”${FULLCHAIN}” > fullchain.crt
echo ”✅ Certificado emitido para ${DOMAIN} y guardado en ${CERT_DIR}”
2.3. Integración con systemd
Para que la rotación sea automática, creamos un timer que ejecute el script cada 30 días.
# /etc/systemd/system/renew-${DOMAIN}.service [Unit] Description=Renovar certificado TLS para ${DOMAIN} After=network-online.target Wants=network-online.target
[Service] Type=oneshot ExecStart=/usr/local/bin/renew_cert.sh ${DOMAIN} Environment=VAULT_ADDR=https://vault.internal:8200 Environment=VAULT_TOKEN=s.xxxxxxx
# /etc/systemd/system/renew-${DOMAIN}.timer
[Unit]
Description=Timer para renovar certificado TLS cada 30d
[Timer]
OnCalendar=*-*-1/30 *:00:00
Persistent=true
[Install]
WantedBy=timers.target
Habilitamos el timer:
systemctl daemon-reload
systemctl enable --now renew-${DOMAIN}.timer
Despliegue en entornos híbridos
On‑prem
En los servidores físicos o VMs, el script se ejecuta directamente y la recarga del servicio se hace con systemctl reload nginx (o el daemon correspondiente). El archivo de certificado se coloca en la ruta esperada por el servicio.
Cloud (Ej. AWS EC2 + EKS)
Para contenedores, se monta un emptyDir o un secret que el script actualiza. En Kubernetes, podemos usar un Init Container que invoque el mismo script y copie los artefactos a /etc/ssl/certs. Alternativamente, el script puede publicar el certificado como Secret usando kubectl create secret tls con la opción --dry-run=client -o yaml | kubectl apply -f -.
Sección de Troubleshooting
Errores comunes
- 400 Bad Request – csr missing: El CSR no está codificado en Base64 o el campo
csrtiene nombre incorrecto. Verifique la salida debase64 -w0 request.csr. - 403 Forbidden – policy violation: El token usado no tiene la policy
cert_renew. Revisevault token lookupy las policies asociadas. - 500 Internal Server Error – unknown issuer: El nombre del emisor (p.e.
internal) no coincide con la ruta configurada enacme/config/issuer. Usevault read acme/config/issuerspara listar. - Timeout al contactar Vault: Problemas de TLS o firewall. Asegúrese de que
VAULT_ADDRsea alcanzable y que el certificado de Vault sea confiable en el host cliente. - El certificado no contiene los SAN esperados: Revise el archivo
csr.confy asegúrese de que la secciónsubjectAltNameliste todos los nombres.
Comandos de diagnóstico
# Ver token y policies vault token lookup -format=json ${VAULT_TOKEN} | jq .data.policiesVer la configuración del emisor ACME
vault read acme/config/issuer/internal
Probar la solicitud manualmente (sin script)
curl -s —header “X-Vault-Token: ${VAULT_TOKEN}”
—request POST
—data ’{“csr”:”’”$(base64 -w0 request.csr)”’”}’
${VAULT_ADDR}/v1/acme/issue/internal/${DOMAIN}
Conclusión
Integrar ACME dentro de HashiCorp Vault y automatizar la emisión con Bash permite mantener certificados TLS internos siempre actualizados, sin intervención manual y con trazabilidad de auditoría centralizada. La solución funciona sin cambios estructurales tanto en datacenters on‑prem como en entornos cloud, y se adapta fácilmente a Kubernetes mediante secretos o init containers.
Recuerda siempre:
- Rotar los tokens de Vault periódicamente.
- Mantener una copia de la CA raíz fuera del clúster (por ejemplo, en un HSM).
- Monitorizar los logs de Vault (
/var/log/vault.log) y los timers de systemd para detectar fallos tempranos.
Con esta arquitectura tu organización reduce el riesgo de expiración de certificados, mejora la postura de seguridad y simplifica la gestión operativa.