~ / posts / oci-kubernetes / vault-y-external-secrets.md
2026-11-20 · 8 min de lectura

P6 - Secretos en OKE: de Terraform al pod con OCI Vault y External Secrets, sin pasar por git

Cómo llegan los secretos al cluster: OCI Vault con una key HSM, un secreto JSON por grupo cargado desde Terraform, External Secrets Operator leyéndolo con instance principal y ExternalSecrets en git que solo dicen qué leer. Lo que hay que cuidar y cuánto cuesta contra Secrets Manager.

tiendisterraformocikubernetesawssecurity

También en dev.to, para comentar y seguir la serie ahí.

Serie «Kubernetes en OCI al menor costo» — parte 6. En la parte 5 vimos cómo lo que corre en el cluster consigue permisos en OCI. Acá va el uso más importante de esos permisos: leer los secretos.

Soy Matías Galiano, arquitecto de plataforma: llevo 18 años escribiendo software y 7 diseñando y operando sistemas distribuidos sobre Kubernetes, con Terraform y GitOps.

Todo lo que corre en el cluster se declara en git y lo aplica ArgoCD. Eso funciona muy bien para los Deployments y los Services, pero choca con una pregunta: ¿dónde van las contraseñas? Un Secret de Kubernetes en git es base64, que no es cifrado: cualquiera con acceso al repo lo lee.

Lo que armé es un camino donde el valor de un secreto nunca toca git. Nace en Terraform, se guarda cifrado en OCI Vault, y un operador dentro del cluster, External Secrets, lo copia como Secret de Kubernetes en el namespace que lo necesita. En git solo queda la indicación de qué secreto leer y cómo armarlo.

Todo sale del Terraform del cluster de producción de Tiendis (vault.tf) y del repo de GitOps.

El recorrido completo#

Flujo de un secreto: terraform.tfvars y las llaves generadas entran a oci_vault_secret, que crea una versión en el Vault; External Secrets la lee y crea el Secret de Kubernetes que el pod usa al arrancar

Ver el diagrama interactivo

Las flechas rojas son los lugares por donde viaja el valor. Las grises, configuración sin ningún dato sensible: eso es lo que vive en git.

El Vault y la key#

Un Vault de OCI es el contenedor de las llaves de cifrado y de los secretos. Hay dos tipos: el virtual (DEFAULT), compartido con otros clientes pero aislado, y el privado, con hardware propio que se cobra por hora. Para esto alcanza con el virtual:

resource "oci_kms_vault" "main" {
  compartment_id = var.compartment_ocid
  display_name   = "proyectos"
  vault_type     = "DEFAULT"
}

resource "oci_kms_key" "main" {
  compartment_id      = var.compartment_ocid
  display_name        = "proyectos-secrets"
  management_endpoint = oci_kms_vault.main.management_endpoint
  key_shape {
    algorithm = "AES"
    length    = 32
  }
}

La key es la llave con la que el Vault cifra los secretos. Por defecto se crea protegida por un HSM, un módulo de hardware del que la llave no sale nunca. Las primeras 20 versiones de keys HSM no se cobran, y los secretos tampoco, así que con una sola key el Vault entero me sale gratis.

Un secreto JSON por grupo#

En vez de un secreto de OCI por cada contraseña, guardo un JSON por grupo lógico: todos los secretos de la API de Tiendis en prd juntos, todos los de dev juntos, las credenciales de Grafana juntas. Así un cambio en la configuración de una app es un solo secreto y una sola versión nueva:

locals {
  vault_secrets = {
    "tiendis-api-secrets-prd" = jsonencode(var.tiendis_secrets_prd)   # del tfvars
    "grafana-admin" = jsonencode({
      admin-user     = var.grafana_admin_user
      admin-password = var.grafana_admin_password
    })
    # Llaves que crea el propio Terraform: nadie las copia a mano
    "objectstorage-s3-loki" = jsonencode({
      access_key = oci_identity_customer_secret_key.s3_loki.id
      secret_key = oci_identity_customer_secret_key.s3_loki.key
      endpoint   = local.s3_compat_endpoint
    })
  }
}

resource "oci_vault_secret" "secrets" {
  for_each       = local.vault_secrets
  compartment_id = var.compartment_ocid
  vault_id       = oci_kms_vault.main.id
  key_id         = oci_kms_key.main.id
  secret_name    = each.key
  secret_content {
    content_type = "BASE64"
    content      = base64encode(each.value)
  }
}

Los secretos vienen de dos lados:

Cuando cambia un valor, Terraform no reemplaza el secreto: le crea una versión nueva, y la anterior queda en el historial del Vault.

Un detalle que me costó entender: for_each no acepta claves que salgan de una variable sensitive, porque las claves de un for_each se muestran en el plan. Para las credenciales de Postgres, que van una por namespace, itero sobre una lista de namespaces que no es sensible, y busco la credencial adentro:

{
  for ns in var.postgres_app_namespaces :     # lista común, no sensible
  "postgres-app-${ns}" => jsonencode(var.postgres_app_credentials[ns])   # mapa sensible
}

External Secrets: del Vault al namespace#

External Secrets Operator (ESO) es un operador que corre en el cluster y sabe leer secretos de muchos proveedores: AWS Secrets Manager, Vault de HashiCorp, OCI Vault y otros. Se configura en dos niveles.

Un ClusterSecretStore, uno para todo el cluster, que dice de dónde leer y con qué identidad. Usa la identidad del nodo, como conté en la parte 5, así que no tiene ninguna llave montada:

apiVersion: external-secrets.io/v1
kind: ClusterSecretStore
metadata:
  name: oci-vault
spec:
  provider:
    oracle:
      region: sa-santiago-1
      vault: <ocid del vault>
      compartment: <ocid del compartment>
      principalType: InstancePrincipal

Y un ExternalSecret por cada Secret que necesita una app, en su namespace, que dice qué secreto del Vault leer y cómo convertirlo. Es lo único que vive en git, y no tiene ningún valor:

apiVersion: external-secrets.io/v1
kind: ExternalSecret
metadata:
  name: finanzas-api-secrets
spec:
  refreshInterval: 1h
  secretStoreRef: { name: oci-vault, kind: ClusterSecretStore }
  target: { name: finanzas-api-secrets }
  dataFrom:
    - extract: { key: finanzas-api-secrets-prd }   # cada clave del JSON, una clave del Secret

El extract es lo que hace útil el JSON por grupo: cada clave del JSON se vuelve una clave del Secret de Kubernetes. Y el pod lo carga entero con envFrom, sin listar variable por variable.

Cuando un Secret necesita un formato especial, ESO tiene templates. El caso que más uso es el de la credencial del registry: en el Vault guardo usuario y token, y el template arma el dockerconfigjson que pide Kubernetes para bajar imágenes privadas:

spec:
  target:
    name: ocir-pull
    template:
      engineVersion: v2
      type: kubernetes.io/dockerconfigjson
      data:
        .dockerconfigjson: |
          {"auths":{"{{ .registry }}":{"username":"{{ .username }}","password":"{{ .token }}",
          "auth":"{{ printf "%s:%s" .username .token | b64enc }}"}}}
  dataFrom:
    - extract: { key: ocir-pull }

Una sola credencial en el Vault y cada namespace arma su propio Secret con el formato correcto.

Lo que hay que cuidar#

Este camino saca los secretos de git, pero no los hace desaparecer. Hay tres lugares donde siguen estando y que conviene tener presentes:

Y un detalle operativo: los pods leen las variables de entorno al arrancar. Si cambio un valor, ESO actualiza el Secret de Kubernetes en menos de una hora (el refreshInterval), pero el pod que ya está corriendo sigue con el valor viejo hasta que lo reinicio. Para una rotación planificada hago el apply, fuerzo el refresco del ExternalSecret y reinicio el Deployment, en ese orden.

Referencias#

Lo mismo en AWS#

AWS OCI
Dónde viven Secrets Manager (o Parameter Store) OCI Vault
Cifrado KMS (USD 1 por key por mes) Key del Vault (las primeras 20 versiones HSM, gratis)
Costo por secreto USD 0,40 por mes Sin costo
Cómo lee el cluster ESO con IRSA o Pod Identity ESO con instance principal (en Basic)
Qué queda en git ExternalSecret ExternalSecret

Tengo 26 secretos en el Vault. En Secrets Manager serían unos USD 10 por mes, más la key de KMS. No es lo que mueve la factura, pero es otra pieza que en OCI no suma.

Lo que viene#

En la próxima entrega, que todavía estoy escribiendo, va el bootstrap de ArgoCD: la única instalación que hago a mano, y cómo a partir de ahí el cluster se arma solo desde el repo de GitOps.

Si te sirvió, el RSS es la mejor forma de enterarte del próximo post.