DEV Community

Matías Galiano
Matías Galiano

Posted on Edited on Originally published at mgaliano.tech

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

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

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

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
  }
}
Enter fullscreen mode Exit fullscreen mode

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)
  }
}
Enter fullscreen mode Exit fullscreen mode

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 marcadas sensitive = true para que Terraform no las muestre en el plan.
  • 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
}
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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 }
Enter fullscreen mode Exit fullscreen mode

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

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.

Top comments (0)