~ / posts / oci-kubernetes / plataforma-kubernetes-vista-general.md
2026-11-17 · 11 min de lectura

Una plataforma Kubernetes completa en OCI, vista de arriba (y su equivalente en AWS)

NATS JetStream, observabilidad con Mimir/Loki/Tempo, Postgres con CloudNativePG, APISIX, ArgoCD y External Secrets: qué hace cada pieza, cómo se conectan y qué servicio de AWS reemplazan.

kubernetesociawsgitopsplatform-engineering

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

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#

Plataforma Kubernetes en OCI: el tráfico entra por Route 53 y un Flexible NLB a APISIX, sigue a las apps, PgBouncer y CloudNativePG; NATS, ArgoCD, External Secrets y la observabilidad (Alloy, Mimir, Loki, Tempo, Grafana) viven en el mismo cluster OKE

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#

Deploy con GitOps: git tag dispara buildx bake en un runner ARM del cluster, la imagen va a OCIR, un commit cambia newTag en el repo gitops y ArgoCD aplica el rolling update

# 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#

Secreto: terraform.tfvars alimenta terraform apply, que crea el secreto en OCI Vault; External Secrets lo lee con el permiso del nodo y lo sincroniza a un Secret de k8s que monta el pod

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#

Request: el cliente resuelve en Route 53, abre TCP :443 contra el Flexible NLB, que pasa la conexión con la IP real a APISIX; APISIX termina TLS y rutea por hostname al pod

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#

Telemetría: pods y navegador envían a Alloy, que escribe en Mimir, Loki y Tempo; los tres guardan sus bloques en Object Storage y Grafana los consulta con PromQL, LogQL y TraceQL y alerta por Telegram

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:

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/zone tiene un único valor y no reparte nada. El dominio de falla real en OKE es oci.oraclecloud.com/fault-domain. Y minDomains: 3 es imprescindible: sin él, 2+1 réplicas sobre dos dominios cumplen maxSkew: 1 y 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.