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.
La serie completa se publica primero en mi web, mgaliano.tech.
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
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:
- Los que escribo yo, como las claves de OAuth o la clave maestra de cifrado de una app, van en
terraform.tfvars, que está fuera de git, en variables marcadassensitive = truepara que Terraform no las muestre en elplan. - Los que genera Terraform, como las llaves S3 de cada componente de la parte 2, la credencial SMTP o la del registry, pasan directo del recurso que las crea al Vault. Nadie las ve ni las copia, y si las roto, el Vault se actualiza en el mismo
apply.
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:
- El
terraform.tfvars, en mi máquina. Está fuera de git y es el origen de todo lo que escribo a mano, así que tiene que tener backup en algún lugar seguro. - El tfstate. Terraform guarda en el state los valores de todo lo que maneja, incluidos los secretos: quien lee el state, lee los secretos. Ninguna de las llaves de las apps llega a ese bucket, porque cada una está limitada al suyo, como conté en la parte 2. Y la policy de los nodos no tiene ningún permiso sobre Object Storage.
- Los Secrets de Kubernetes. Una vez que ESO los crea, cualquiera con permiso de leer Secrets en ese namespace los ve. El RBAC del cluster sigue importando.
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
- Overview of Vaults and Key Management: tipos de vault, keys y cómo se protegen.
- Managing Secrets: secretos, versiones y rotación.
- Key Management with OCI Vault: la página del producto, con las preguntas frecuentes de precios.
- External Secrets: Oracle Vault y templating: el proveedor de OCI y cómo armar Secrets con formato propio.
-
for_eachen Terraform y datos sensibles: por qué las claves no pueden ser sensibles y qué guarda el state. - Del lado de AWS: precios de Secrets Manager y de KMS.
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.
Todos los posts de la serie, y lo que voy publicando sobre arquitectura, cloud y Kubernetes,
están en mgaliano.tech/blog.

