Serie «Kubernetes en OCI al menor costo» — parte 4. En la parte 3
armamos la red. Ahora va el cluster y las máquinas donde corre todo.
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.
Esta es la parte donde más cosas fui cambiando sobre la marcha. El tamaño de los nodos, cómo se
reparten y el autoscaler los ajusté varias veces, y casi siempre después de que algo me mostrara
que la primera versión no alcanzaba. Cuento lo que tengo hoy y cómo llegué hasta acá.
Todo sale del Terraform del cluster de producción de Tiendis (oke.tf y
nodepools.tf) y de la configuración del autoscaler en el repo de GitOps.
El cluster: OKE Basic
resource "oci_containerengine_cluster" "oke" { compartment_id = var.compartment_ocid name = "proyectos" vcn_id = oci_core_vcn.main.id kubernetes_version = "v1.37.1" type = "BASIC_CLUSTER" # control plane sin costo, sin SLA endpoint_config { subnet_id = oci_core_subnet.public.id is_public_ip_enabled = true nsg_ids = [oci_core_network_security_group.cp_endpoint.id] } cluster_pod_network_options { cni_type = "FLANNEL_OVERLAY" } options { service_lb_subnet_ids = [oci_core_subnet.public.id] kubernetes_network_config { pods_cidr = "10.244.0.0/16" services_cidr = "10.96.0.0/16" } } } Sobre el FLANNEL_OVERLAY, en criollo: cada pod necesita una dirección IP para que los demás lo
encuentren. Con flannel, Kubernetes arma su propia red "por arriba" de la red de OCI: los pods
reciben direcciones de un rango aparte (10.244.0.0/16), y cuando un pod le habla a otro que está
en otro nodo, flannel mete ese mensaje dentro de un paquete normal entre los dos nodos, como una
carta dentro de otro sobre. La red de OCI solo ve tráfico entre nodos y no se entera de que hay
pods. La alternativa (VCN-native) le da a cada pod una IP real de la subnet, como hace EKS. En la
parte 3 cuento por qué elegí flannel y qué me costó.
OKE tiene dos tipos de cluster. Basic no cobra el control plane, pero no tiene SLA con
respaldo financiero. Enhanced cuesta USD 0,10 por hora (unos USD 74 por mes) y suma el SLA,
workload identity y los nodos virtuales. Para el tamaño de mis proyectos elegí Basic: son USD 74
menos por mes, y la falta de workload identity la resolví con instance principal (lo cuento en
una próxima entrega).
Una vez creado, el kubeconfig se genera con la CLI:
oci ce cluster create-kubeconfig --cluster-id <cluster_ocid> --region sa-santiago-1 \ --file ~/.kube/config --token-version 2.0.0 --kube-endpoint PUBLIC_ENDPOINT Diferencia con AWS: EKS cobra el control plane siempre (USD 0,10 por hora, y USD 0,60 si la
versión pasa a soporte extendido). En OCI se puede no pagarlo, a cambio del SLA.
Las versiones vencen. OKE soporta pocas versiones de Kubernetes a la vez: la v1.36.1 que
corría quedó fuera de soporte el 3 de noviembre, y pasé a la v1.37.1. El orden fue el de
siempre: primero el control plane (sin corte) y después los nodos, que OKE va reemplazando por
nodos nuevos con la versión actualizada. Durante esa rotación conviene pausar el scale-down del autoscaler; más abajo cuento por
qué.
La imagen de los nodos
Los nodos usan la imagen de Oracle Linux que publica OKE para cada versión de Kubernetes. En lugar
de fijar un OCID a mano, la busco con un filtro, así al subir de versión la imagen se actualiza
sola:
data "oci_containerengine_node_pool_option" "oke" { node_pool_option_id = "all" compartment_id = var.compartment_ocid } locals { arm_sources = [ for s in data.oci_containerengine_node_pool_option.oke.sources : s if can(regex("^Oracle-Linux-9\\..*aarch64", s.source_name)) && # OL9 y ARM !can(regex("GPU", s.source_name)) && can(regex("OKE-${trimprefix(var.kubernetes_version, "v")}-", s.source_name)) ] # Ordenadas por nombre, la más nueva de esa versión queda última node_image_id = [for n in sort([for s in local.arm_sources : s.source_name]) : one([for s in local.arm_sources : s if s.source_name == n])][length(local.arm_sources) - 1].image_id } Pedir Oracle Linux 9 de forma explícita me evitó un problema: sin ese filtro, el primer
resultado podía ser una imagen de Oracle Linux 8.
El cloud-init: cri-o y los nombres cortos
Kubernetes no corre los contenedores por sí mismo: en cada nodo, el kubelet (el agente que recibe
las órdenes del cluster) le pide a un runtime de contenedores que baje la imagen y arranque el
proceso. Es la pieza que antes hacía Docker; hoy los más comunes son containerd, el que usa
EKS, y cri-o, uno hecho específicamente para Kubernetes. En el día a día no se nota cuál hay,
porque los manifiestos son los mismos, pero cada uno tiene sus valores por defecto.
OKE usa cri-o, y cri-o viene configurado para rechazar imágenes con nombre corto. Un
image: nats:2.12 falla con ImageInspectError en vez de bajar docker.io/nats:2.12. Muchos
charts de Helm usan nombres cortos, así que lo resolví en el arranque del nodo:
locals { node_cloud_init = <<-EOT #!/usr/bin/env bash mkdir -p /etc/containers/registries.conf.d printf 'short-name-mode = "permissive"\nunqualified-search-registries = ["docker.io"]\n' \ > /etc/containers/registries.conf.d/99-shortnames.conf # El script de OKE que une el nodo al cluster: hay que llamarlo sí o sí curl --fail -H "Authorization: Bearer Oracle" -L0 \ http://169.254.169.254/opc/v2/instance/metadata/oke_init_script | base64 --decode > /var/run/oke-init.sh bash /var/run/oke-init.sh EOT } El detalle importante es la última parte: al pasar un user_data propio se reemplaza el que trae
OKE, así que hay que bajar y ejecutar oke_init_script a mano. Sin eso, el nodo arranca pero
nunca se une al cluster.
Diferencia con AWS: EKS usa containerd, que completa los nombres cortos con docker.io sin
quejarse. Este problema no existe ahí.
El node pool: de 6 nodos chicos a 3 grandes
Abrí el diagrama interactivo
para recorrerlo pieza por pieza.
Arranqué con 6 nodos de 2 OCPU y 12 GB. Hoy son 3 nodos de 4 OCPU y 20 GB, uno por fault
domain, y el autoscaler puede sumar un cuarto:
resource "oci_containerengine_node_pool" "apps" { cluster_id = oci_containerengine_cluster.oke.id compartment_id = var.compartment_ocid name = "pool-apps" kubernetes_version = var.kubernetes_version node_shape = "VM.Standard.A1.Flex" node_metadata = { user_data = base64encode(local.node_cloud_init) } node_shape_config { ocpus = 4 memory_in_gbs = 20 } node_source_details { source_type = "IMAGE" image_id = local.node_image_id boot_volume_size_in_gbs = 50 } node_config_details { size = 3 placement_configs { availability_domain = local.ad_name subnet_id = oci_core_subnet.private.id fault_domains = local.fd_names # los tres, en un solo placement_config } nsg_ids = [oci_core_network_security_group.workers.id] } initial_node_labels { key = "pool" value = "apps" } ssh_public_key = var.ssh_public_key # El tamaño lo maneja el cluster-autoscaler lifecycle { ignore_changes = [node_config_details[0].size] } } Por qué el cambio, con los números de OCI (que cobra por OCPU y por GB, no por instancia):
- La CPU total es la misma: 12 OCPU antes y después, así que el cómputo no cambia.
- Baja la RAM: de 72 GB a 60 GB, y en OCI la RAM pesa casi tanto como la CPU.
- La mitad de discos de boot: 50 GB es el mínimo por nodo, y con 3 nodos pago 3 discos en vez de 6.
- Un nodo por fault domain: con 6 nodos repartidos 3/2/1, separar por nodo y por fault domain a la vez no cerraba; con 3, una réplica por nodo es lo mismo que una por fault domain.
La contrapartida es real: cada nodo es un tercio del cluster. Si se cae uno, la réplica de
Postgres o de NATS de ese fault domain queda Pending hasta que el pool recrea el nodo, unos 5 a
8 minutos. Para mí es un costo aceptable; para otro proyecto quizás no.
El reparto por fault domain que se me rompió
Al principio tenía un placement_config por fault domain, tres bloques, uno por nodo. Funcionó
hasta que entró el autoscaler. El autoscaler solo cambia el size del pool y no sabe repartirlo
entre varios placement_configs, así que con el tiempo el pool derivó a uno solo, y un día
encontré los 4 nodos en FAULT-DOMAIN-1:
kubectl get nodes -L oci.oraclecloud.com/fault-domain Con todos los nodos en el mismo hardware, Postgres y NATS, que exigen una réplica por fault domain,
quedaban con una sola réplica programable y el resto en Pending:
topologySpreadConstraints: - topologyKey: oci.oraclecloud.com/fault-domain maxSkew: 1 minDomains: 3 whenUnsatisfiable: DoNotSchedule La solución fue un solo placement_config con la lista de los tres fault domains, como está
arriba. Así OKE reparte cada nodo nuevo entre los tres, incluidos los que crea el autoscaler, y el
reparto se sostiene solo.
El label que importa. En una región con una sola AD, como Santiago,
topology.kubernetes.io/zone
tiene un único valor y no reparte nada. El dominio de falla real es
oci.oraclecloud.com/fault-domain: hardware físico distinto dentro de la misma AD.
El cluster-autoscaler
En OKE no hay Karpenter ni Auto Mode: se usa el cluster-autoscaler clásico, con el proveedor de
OCI. Lo instalo con ArgoCD, y estos son los valores que importan:
cloudProvider: oci autoscalingGroups: - name: <node_pool_ocid> # pool-apps minSize: 3 maxSize: 4 extraEnv: OCI_USE_INSTANCE_PRINCIPAL: "true" # usa el permiso del nodo, sin llaves OCI_REGION: sa-santiago-1 extraArgs: balance-similar-node-groups: "true" scale-down-unneeded-time: 5m scale-down-delay-after-add: 5m image: tag: v1.37.0 # misma minor que Kubernetes Tres cosas que aprendí con él:
- La versión va pegada a la de Kubernetes. El autoscaler se versiona por minor de Kubernetes. En algún momento quedó en la v1.32 con el cluster en la v1.36, cuatro minors atrás, y entre otras cosas logueaba errores de permisos. Desde entonces lo subo junto con el cluster.
- Necesita permiso sobre los node pools. Con instance principal, el permiso es del nodo: la policy del dynamic group de los nodos tiene que incluir
manage cluster-node-pools. - Ojo al rotar nodos a mano. Un nodo recién creado arranca casi vacío, y el autoscaler lo marca como innecesario y a los 5 minutos lo borra. Me pasó en plena rotación: se comió el nodo nuevo de un fault domain. Ahora, antes de rotar, pongo
scale-down-enabled: "false"y lo vuelvo a activar al terminar.
El maxSize: 4 también tiene su historia: con nodos de 2 OCPU el techo era 6; al pasar a nodos de
4 OCPU, mantener 6 habría sido un techo de 24 OCPU. Con 3 nodos el cluster corre entre el 27 y el
70 % de CPU, así que un cuarto nodo alcanza como margen.
Diferencia con AWS: Karpenter (o EKS Auto Mode) elige el tipo de instancia en el momento, según
lo que piden los pods. El cluster-autoscaler de OKE solo cambia el tamaño de pools que ya
existen: la forma del nodo la decidís vos de antemano.
Lo que todavía tengo pendiente: el pool de CI
Creé un segundo pool, pool-ci, pensado para los runners de CI: nodos de 2 OCPU y 8 GB, con disco
de 100 GB para la caché de builds, que arrancara en 0 y escalara a 2 solo cuando hubiera un build.
Hoy ese pool está en 0 y no se usa: no lo registré en el autoscaler y los runners no lo piden,
así que los builds corren en los nodos de apps, al lado de producción. Y eso ya me jugó en
contra: un día tres builds con Docker en Docker al mismo tiempo colgaron cri-o y dejaron un nodo
NotReady, con pods de producción adentro. La solución rápida fue lanzar los releases de a uno.
La solución de fondo es terminar lo que empecé:
- Registrar
pool-cien el autoscaler conminSize: 0ymaxSize: 2. - Ponerle un taint al pool, para que solo los runners puedan correr ahí.
- Darle a los runners la toleration y un
nodeSelectorconpool: ci.
Lo voy a contar cuando lo termine, en la entrega del CI dentro del cluster.
Resumen: lo mismo en AWS y en OCI
| Tema | AWS (EKS) | OCI (OKE) |
|---|---|---|
| Control plane | USD 0,10/h siempre | Basic sin costo (sin SLA) o Enhanced USD 0,10/h |
| Imagen de nodos | AMI de EKS optimizada | Oracle Linux de OKE, elegida con filtro |
| Runtime | containerd | cri-o (ojo con los nombres cortos) |
| Autoscaling | Karpenter / Auto Mode eligen la instancia | cluster-autoscaler sobre pools existentes |
| Dominio de falla | AZ (topology.kubernetes.io/zone) | Fault domain (oci.oraclecloud.com/fault-domain) |
| Permiso del autoscaler | IRSA / Pod Identity | Instance principal (del nodo) |
Lo que viene
En la próxima entrega, que todavía estoy escribiendo, va el IAM de los nodos: dynamic groups,
instance principal y qué significa, en la práctica, que el permiso sea del nodo y no del pod.
Todos los posts de la serie, y lo que voy publicando sobre arquitectura, cloud y Kubernetes,
están en mgaliano.tech/blog.
