~ / posts / oci-kubernetes / operadores-base.md
2026-11-22 · 10 min de lectura

P8 - Certificados, DNS y discos en OKE: los operadores que hacen que una app nueva se publique sola

cert-manager con DNS-01 contra Route 53, external-dns leyendo rutas de Gateway API, una llave de AWS que solo sabe tocar DNS, el CSI de block volumes con su mínimo de 50 GB y metrics-server, que OKE no trae. Lo que aprendí de cada uno y cuánto cuesta contra EKS.

tiendisocikubernetesawsdnstls

Serie «Kubernetes en OCI al menor costo» — parte 8. En la parte 7 vimos cómo ArgoCD arma el cluster desde git. Acá van los primeros operadores que instala, los que hacen que una app nueva tenga certificado, nombre y disco sin que yo toque nada.

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.

Cuando subo una app nueva, en el repo escribo su Deployment y una ruta con el nombre con el que quiero que se vea, por ejemplo api.dev.tiendis.app. Para que eso funcione hacen falta tres cosas más: un registro DNS que apunte al gateway, un certificado TLS válido para ese nombre y, si la app guarda datos, un disco. Ninguna de las tres la hago a mano: las hace un operador, un programa que corre en el cluster, mira ciertos recursos y crea lo que hace falta para que se cumplan.

Este post va de esos operadores: cert-manager, external-dns, el CSI de los discos y metrics-server. Todos salen del repo de GitOps del cluster de producción de Tiendis.

El DNS sigue en AWS#

Un detalle condiciona todo lo demás: el cluster está en OCI, pero las zonas DNS siguen en Route 53, el DNS de AWS. Cuando migré, como conté en la parte 0, lo que se mudó fue el cómputo: el DNS, los buckets de assets y el CDN se quedaron en AWS, porque ahí no estaba el costo y moverlos era riesgo sin ahorro.

Eso quiere decir que dos operadores de un cluster de OCI tienen que escribir en una API de AWS. Y OKE no tiene nada parecido a IRSA, el mecanismo de EKS para darle a un pod un rol de AWS sin llaves. Desde otra nube, la única opción simple es una llave de acceso de un usuario de IAM, guardada en el Vault y entregada por External Secrets como cualquier otro secreto.

Al escribir este post encontré que esa llave era la misma que usaba todo el cluster para S3: además de tocar DNS, podía escribir y borrar en los buckets de producción, incluido el de imágenes, que no tiene versionado. Un bug en external-dns, o una imagen comprometida, podía borrar archivos que no se recuperan. La separé: ahora cert-manager y external-dns tienen un usuario propio que solo sabe cambiar registros en las zonas del cluster:

resource "aws_iam_user" "oke_dns" {
  name = "oci-oke-dns"
  path = "/service/"
}

data "aws_iam_policy_document" "oke_dns" {
  statement {
    actions   = ["route53:ChangeResourceRecordSets", "route53:ListResourceRecordSets"]
    resources = [for z in data.aws_route53_zone.z : z.arn]   # solo las zonas del cluster
  }
  statement {
    actions   = ["route53:ListHostedZones", "route53:ListHostedZonesByName", "route53:GetChange"]
    resources = ["*"]   # estas acciones no aceptan una zona concreta
  }
}

resource "aws_iam_user_policy" "oke_dns" {
  name   = "oci-oke-route53"
  user   = aws_iam_user.oke_dns.name
  policy = data.aws_iam_policy_document.oke_dns.json
}

La llave nueva va al Vault como un secreto propio, aws-route53, y los ExternalSecrets de cert-manager y external-dns leen de ahí. La mudanza fue en dos pasos para no cortar nada: primero el usuario nuevo y los operadores usándolo; después, con un certificado de prueba emitido con la llave nueva y external-dns leyendo todas las zonas sin errores, saqué los permisos de Route 53 del usuario viejo. La llave de S3 quedó para las apps que de verdad usan S3. El principio es el mismo de la parte 5: cada componente con lo mínimo que necesita, aunque cueste un usuario más.

cert-manager: certificados con DNS-01#

cert-manager pide certificados a Let's Encrypt y los renueva antes de que venzan. Para emitirlos, Let's Encrypt pide una prueba de que el dominio es mío, el challenge. Hay dos formas:

Como las zonas son mías, uso DNS-01 para todo. La configuración es un ClusterIssuer, que sirve para todo el cluster:

apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
  name: letsencrypt-prod
spec:
  acme:
    server: https://acme-v02.api.letsencrypt.org/directory
    privateKeySecretRef: { name: letsencrypt-prod-account }
    solvers:
      - dns01:
          route53:
            region: us-east-1
            accessKeyIDSecretRef: { name: route53-credentials, key: AWS_ACCESS_KEY_ID }
            secretAccessKeySecretRef: { name: route53-credentials, key: AWS_SECRET_ACCESS_KEY }

Cada nombre tiene su Certificate en el repo, al lado del Gateway o de la app que lo usa. Es corto: el nombre, el issuer y el Secret donde dejar el resultado:

apiVersion: cert-manager.io/v1
kind: Certificate
metadata: { name: argocloud-tls, namespace: gateway-apisix-prd }
spec:
  secretName: argocloud-tls
  issuerRef: { name: letsencrypt-prod, kind: ClusterIssuer }
  dnsNames: ["argocloud.mgaliano.tech"]

Hoy son 26 certificados, todos vigentes, y no renové ninguno a mano.

El resolver de la VCN y los dominios nuevos#

Antes de pedirle a Let's Encrypt que valide, cert-manager comprueba por su cuenta que el TXT ya se ve. Por defecto lo hace con el DNS del cluster, que en OCI termina en el resolver de la VCN. Con un dominio recién registrado, ese resolver guardó en cache la respuesta «este dominio no existe» de antes de la delegación, y el certificado quedó trabado esperando un registro que para él no existía. La solución es que cert-manager pregunte a resolvers públicos:

extraArgs:
  - --dns01-recursive-nameservers-only
  - --dns01-recursive-nameservers=1.1.1.1:53,8.8.8.8:53

Los dominios de los clientes#

Hay un caso donde DNS-01 no sirve: las tiendas de Tiendis pueden usar un dominio propio, como tienda.dominiocliente.com, y esa zona no es mía. Para esos uso un segundo ClusterIssuer con HTTP-01: el cliente apunta su dominio al gateway, y cert-manager responde el challenge por el puerto 80. Lo dispara la propia app: cuando el cliente configura su dominio, crea la ruta con la anotación del issuer, y cert-manager hace el resto.

external-dns: el registro que aparece solo#

external-dns lee las rutas del cluster y crea los registros DNS que piden. Le digo qué fuentes mirar, en qué zonas puede escribir y cómo marcar lo que es suyo:

provider:
  name: aws
sources:
  - gateway-httproute
  - service
domainFilters:
  - tiendis.app
  - emprenum.com
  - mgaliano.tech
registry: txt
txtOwnerId: oke-proyectos
policy: upsert-only

Dos cosas que aprendí actualizando:

Discos: el CSI de block volumes#

Para los datos que tienen que sobrevivir a un pod, como Postgres o el almacenamiento de NATS, uso volúmenes. OKE trae instalado el CSI de block volumes, el driver que crea un disco de OCI cuando alguien pide un PersistentVolumeClaim, y una StorageClass por defecto, oci-bv:

NAME               PROVISIONER                       VOLUMEBINDINGMODE      ALLOWVOLUMEEXPANSION
oci                oracle.com/oci                    Immediate              false
oci-bv (default)   blockvolume.csi.oraclecloud.com   WaitForFirstConsumer   true

En OCI un block volume tiene un mínimo de 50 GB, y la documentación de OKE lo dice explícitamente: un PVC que pide menos se redondea a 50 GB. Un PVC de 5 GB crea un disco de 50 GB, y se cobra como tal. Nueve de mis diez volúmenes son de 50 GB, aunque varios usan una fracción. Con 10 VPU (volume performance units, el nivel de rendimiento que se paga aparte del espacio), cada uno sale unos USD 2,13 por mes, como conté en la parte 0. No es mucho, pero conviene saberlo antes de darle un volumen a cada cosa que lo pida: dos volúmenes de 1 GB cuestan lo mismo que dos de 50 GB.

metrics-server: OKE no lo trae#

El HPA escala los pods según la CPU o la memoria que usan, y esos números los da metrics-server. EKS lo ofrece como un add-on; OKE no lo instala, así que va como una Application más:

args:
  - --kubelet-insecure-tls

Ese argumento hace que metrics-server no verifique el certificado del kubelet de cada nodo, porque en OKE ese certificado no está firmado por la CA del cluster. Es lo que hace casi todo el mundo, y lo que acepto al hacerlo es que metrics-server confía en cualquier cosa que le responda en la IP del nodo. Como ese tráfico no sale de la subred privada de los nodos, para métricas de CPU y memoria me parece un costo razonable.

Referencias#

Lo mismo en AWS#

AWS (EKS) OCI (OKE)
Permiso para Route 53 IRSA o Pod Identity, sin llaves Usuario de IAM con llave, en el Vault
Certificados cert-manager, o ACM si el TLS termina en un ALB cert-manager
DNS automático external-dns external-dns, el mismo
Discos CSI de EBS (add-on), desde 1 GB CSI de block volumes (incluido), desde 50 GB
metrics-server Add-on Una Application más

Las herramientas son las mismas: cert-manager y external-dns no saben en qué nube corren. Lo que cambia es cómo consiguen permiso. En EKS, external-dns hablaría con Route 53 con un rol asumido por su service account, sin ninguna llave guardada. Desde OCI, la llave existe, así que lo que me toca cuidar es que pueda hacer lo menos posible, y rotarla de vez en cuando.

Lo que viene#

En la próxima entrega, que todavía estoy escribiendo, va la entrada del tráfico: un load balancer de red con IP reservada, APISIX con Gateway API, una instancia por entorno, y cómo llega la IP real del cliente hasta la app.

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