Serie «Kubernetes en OCI al menor costo» — parte 1. En la parte 0
vimos por qué OCI y cuánto cuesta. Acá está el mapa de todo lo que vamos a construir.
Un cluster de Kubernetes recién creado no sirve para producción: le faltan la forma de
recibir tráfico, los certificados, los secretos, una base de datos, mensajería, métricas, logs
y una manera reproducible de desplegar. En AWS gran parte de eso lo resolvés contratando
servicios gestionados (ALB, ACM, Secrets Manager, RDS, SQS, CloudWatch). En esta serie lo
resolvemos dentro del cluster con software open source, que es más barato y portable, a
cambio de operarlo vos.
Este post es el mapa. La idea es que, en próximas entregas, cada pieza tenga su propio post de
cómo funciona por dentro.
El diagrama
Abrí el diagrama interactivo para recorrerlo pieza por pieza.
Las piezas y su equivalente en AWS
| Pieza | Para qué | Equivalente en AWS | Diferencia clave |
|---|---|---|---|
| OKE Basic | Control plane de Kubernetes | EKS | Sin costo y sin SLA, contra USD 0,10/h con SLA |
| Node pools A1 + cluster-autoscaler | Nodos ARM que escalan | Managed node groups / Karpenter / Auto Mode | En OKE no hay Karpenter: el autoscaler escala node pools existentes, no elige el tipo de instancia |
| Flexible NLB | Entrada L4 con IP fija | NLB | El de OCI no cobra hora ni tráfico procesado |
| APISIX | Gateway L7: rutas, TLS, rate limit, websockets | ALB + AWS Load Balancer Controller, o API Gateway | Lo operás vos, pero el costo es fijo y no hay precio por request ni por LCU |
| cert-manager | Certificados TLS automáticos | ACM | ACM es gratis pero solo se usa en ALB/NLB/CloudFront. cert-manager deja el certificado como un Secret usable por cualquier pod |
| external-dns | Registros DNS desde los HTTPRoute | Route 53 + integración del LB Controller | Igual, apuntando a Route 53 desde otra nube |
| NATS JetStream | Mensajería, colas, streams y KV | SNS + SQS, EventBridge, Kinesis, ElastiCache | Un componente en vez de cuatro servicios. Lo operás vos, incluido el quórum |
| CloudNativePG | Postgres con HA, backups y PITR | RDS / Aurora | Backups barman a Object Storage. Lo que RDS te da hecho (parches, failover probado), acá es tu responsabilidad |
| Mimir · Loki · Tempo | Métricas, logs y trazas | CloudWatch Metrics/Logs, X-Ray, Managed Prometheus | Se paga storage barato en vez de ingesta: CloudWatch Logs cobra por GB ingerido |
| Grafana + Alloy + Faro | Dashboards, alertas, agente y RUM | Managed Grafana, CloudWatch Alarms, CloudWatch RUM | Estándares abiertos (OpenTelemetry, PromQL, LogQL) en vez de APIs propietarias |
| ArgoCD | GitOps: el cluster refleja un repo git | Argo CD gestionado (EKS Capabilities), o CodePipeline / CodeDeploy | El de AWS solo despliega a clusters EKS y cobra USD 0,03/h más USD 0,0015/h por Application y por cluster destino: con mis 52 Applications serían ~USD 79/mes. Instalado en el cluster no cobra nada aparte de sus recursos |
| External Secrets + OCI Vault | Secretos de la nube como Secret de k8s | Secrets Manager + ESO o el Secrets Store CSI Driver | El operador es el mismo. Cambia solo el SecretStore |
| OCIR | Registry de imágenes | ECR | Equivalentes. Ojo con el formato de usuario <namespace>/<usuario> en docker login |
| OCI Object Storage | Backups, chunks de métricas, logs y trazas | S3 | Tiene endpoint S3-compatible, pero no es S3: hay operaciones que no soporta (lo voy a contar en una próxima entrega, con el tfstate) |
Cómo se organiza el código: dos repos
infra/ # Terraform — lo que vive en la API de OCI network.tf VCN, subnets, gateways, NSG, IPs públicas reservadas oke.tf cluster (BASIC_CLUSTER, FLANNEL_OVERLAY) nodepools.tf pool de apps + pool de CI escalable a 0 iam.tf dynamic groups + policies vault.tf vault, key y secretos fuente ocir.tf object_storage.tf budget.tf gitops/ # ArgoCD — lo que vive dentro del cluster base/ app raíz, AppProjects, ApplicationSets, repos runtime/ un dir por componente: values del chart + manifiestos extra apps/<producto>/{base,dev,prd}/<servicio> kustomize base + overlays La regla es simple: Terraform crea lo que la nube factura; ArgoCD instala lo que corre
dentro del cluster. Terraform no instala charts de Helm y ArgoCD no crea recursos de la nube.
Hay una sola excepción, el arranque: ArgoCD se instala una única vez a mano, y después se
gestiona a sí mismo.
Los cuatro flujos que hay que entender
1. Un deploy
# gitops/apps/tienda/prd/api/kustomization.yaml images: - name: api newName: <region>.ocir.io/<namespace>/tienda/api newTag: v1.4.2 # ← el deploy es este diff El runner corre en un node pool ARM que escala de 0 a 2, así que buildear arm64 es nativo
y rápido (emular con QEMU desde un runner x86 multiplica los tiempos). En AWS lo típico es
CodePipeline/CodeBuild empujando a ECR y llamando a kubectl o
CodeDeploy (push). Con GitOps, el estado deseado queda versionado en git y un rollback es
un git revert.
2. Un secreto
apiVersion: external-secrets.io/v1beta1 # ESO 0.14; desde 0.17 la API estable es external-secrets.io/v1 kind: ClusterSecretStore metadata: { name: oci-vault } spec: provider: oracle: vault: <vault_ocid> region: sa-santiago-1 principalType: InstancePrincipal # Basic no tiene workload identity Diferencia con AWS: con IRSA o Pod Identity el permiso para leer Secrets Manager se le da
al service account de ESO. En OKE Basic se da con instance principal al nodo, mediante
un dynamic group y una policy (Allow dynamic-group oke-nodes to read secret-family in compartment +
id <ocid>use keys). Funciona, pero cualquier pod de ese nodo que use el SDK de OCI hereda
ese permiso, y también los demás que tenga el dynamic group (el cluster-autoscaler, por ejemplo,
necesita manage cluster-node-pools). Por eso las policies del dynamic group tienen que ser las
mínimas, y en un solo compartment.
3. Una request
El NLB trabaja en L4 y el TLS lo termina APISIX con el certificado que emite cert-manager.
En AWS lo normal es un ALB por Ingress, que termina TLS con ACM y cobra por hora y por
LCU. Acá hay un NLB por entorno con IP reservada, y el ruteo L7 lo hace APISIX.
4. Una métrica, un log, una traza
En AWS CloudWatch cobra por GB de logs ingerido y por métrica custom. Acá el costo es el
storage, que es barato, más la RAM de los componentes, que no lo es tanto: en mi caso
el stack de observabilidad es el mayor consumidor de memoria del cluster. Ese es el trade-off
real.
NATS JetStream: por qué una sola pieza reemplaza cuatro
NATS es un sistema de mensajería. JetStream le agrega persistencia: streams (logs de
mensajes durables, parecidos a Kinesis o a un topic de Kafka), consumers (cursores con ack,
parecidos a una cola SQS) y un Key-Value store encima. En Tiendis es la pieza sobre la
que se apoyan varios patrones de integración, cada uno con su equivalente en AWS:
- Transactional outbox. La orden y su evento se guardan en la misma transacción de Postgres; un proceso de fondo (
OrderOutboxProcessor) los toma con un lease y recién ahí publicacore.order.created/updateda JetStream, avisa en tiempo real al panel del comercio y dispara los efectos secundarios (el link de pago de MercadoPago, los mensajes del chat del pedido). Si NATS está caído, el evento no se pierde: queda pendiente y se reintenta. En AWS: el mismo outbox con SQS, o DynamoDB Streams / EventBridge Pipes. - Publish-subscribe con consumers durables. La integración con sistemas POS consume los streams de órdenes y de catálogo con un durable consumer y ack explícito: si el worker se reinicia, retoma donde quedó. Detrás, cada proveedor es un adapter que implementa la misma interfaz (ports & adapters), así sumar un POS nuevo no toca el core. En AWS: EventBridge + SQS.
- Cache-aside con invalidación por eventos. El storefront público se cachea en un bucket KV y, cuando el comercio edita algo, un evento
storefront.invalidatedle llega a todos los pods del front SSR (fan-out). En AWS: ElastiCache + SNS con una SQS por consumidor. - Request-reply. El módulo de POS le pide al core el snapshot de catálogo o una orden por NATS, y el API le pide al worker que sincronice MercadoPago, sin exponer endpoints HTTP internos ni acoplar los servicios. En AWS: una API privada o una invocación de Lambda.
- Idempotency keys + lock distribuido. Las requests con
Idempotency-Keytoman un lock en KV, guardan el resultado y ante un reintento devuelven la misma respuesta sin volver a ejecutar (clave para no crear dos órdenes por un doble click o un reintento de red). En AWS: escrituras condicionales en DynamoDB. - Circuit breaker y degradación controlada. Si NATS no responde, un breaker compartido por todo el proceso se abre y las operaciones fallan rápido en vez de sumar timeouts; la coordinación (locks e idempotencia) cae a Postgres. La plataforma se degrada, no se cae.
- Señales efímeras a tiempo real. La disponibilidad de reservas viaja por NATS core (sin persistencia) a todos los pods del API, que la empujan al navegador por SSE. En AWS: API Gateway WebSockets + SNS.
- Caché de dependencias externas con TTL. Geocoding (90 días) y los tickets de autenticación de ARCA (12 h) viven en KV: menos latencia, menos costo y menos cupo consumido en APIs de terceros.
Lo que todavía no hay es CQRS: el storefront es cache-aside sobre el mismo modelo de
escritura. Materializarlo como un modelo de lectura proyectado desde estos mismos eventos es
el paso siguiente natural, y lo quiero desarrollar en un próximo post dedicado a JetStream.
nats stream ls # streams y cuántos mensajes/bytes tienen nats consumer report STOREFRONT nats kv ls # buckets KV nats server report jetstream # estado del cluster: quién es líder, réplicas al día Corre como 3 réplicas con quórum (Raft). Esto es lo que más se paga en operación: si se
pierden 2 de 3 nodos, JetStream deja de aceptar escrituras. A mí me pasó en EKS (6 horas sin
quórum), y por eso en OKE cada réplica va en un fault domain distinto:
topologySpreadConstraints: - topologyKey: oci.oraclecloud.com/fault-domain # en AWS: topology.kubernetes.io/zone maxSkew: 1 minDomains: 3 whenUnsatisfiable: DoNotSchedule - topologyKey: kubernetes.io/hostname # y nunca dos réplicas en la misma VM maxSkew: 1 minDomains: 3 whenUnsatisfiable: DoNotSchedule Ojo con el label. En una región de una sola AD,
topology.kubernetes.io/zonetiene un
único valor y no reparte nada. El dominio de falla real en OKE es
oci.oraclecloud.com/fault-domain. YminDomains: 3es imprescindible: sin él, 2+1 réplicas
sobre dos dominios cumplenmaxSkew: 1y el scheduler no se queja.
Postgres con CloudNativePG
CloudNativePG es un operador: vos declarás un Cluster y él crea el primario, las
réplicas, los servicios -rw/-ro, el failover y los backups.
kubectl cnpg status pg-prd -n databases # plugin kubectl-cnpg kubectl get backups,scheduledbackups -n databases Los backups (WAL continuo + base backup diario) van con barman a Object Storage, con
retención de 14 días. Eso permite restaurar a cualquier punto en el tiempo (PITR). Contra RDS:
RDS te da todo esto con un checkbox y lo prueba por vos. Con CNPG el restore es tu
responsabilidad, y si no lo probaste no tenés backups, tenés archivos. Restaurar en serio va a tener
su propio post más adelante.
Lo que viene
En las próximas partes, que todavía estoy escribiendo, vamos a construir todo con Terraform y comandos reales: estado y acceso,
red, cluster y node pools, IAM, Vault + External Secrets, bootstrap de ArgoCD, operadores base,
APISIX, CI en el cluster y control de costos. Y en paralelo, más adelante, una serie de cómo funciona para
NATS, cada pata de la observabilidad, CNPG, APISIX y ArgoCD, siempre comparando con su
equivalente en AWS.






