DEV Community

Matías Galiano
Matías Galiano

Posted on Originally published at mgaliano.tech

P3 - La red de un cluster OKE: una VCN, dos subnets y gateways que no se cobran

Serie «Kubernetes en OCI al menor costo» — parte 3. En la parte 2
dejamos lista la cuenta, la identidad y el state. Acá va la red donde después vive el cluster.

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.

En AWS la red fue, durante meses, una de las partes más caras de mi factura: en julio, el NAT
Gateway y el tráfico entre zonas sumaron más de USD 80, no tan lejos de lo que costaba el cómputo. En OCI esa
misma red no se cobra. Pero que sea gratis no significa que dé igual cómo se arma, y acá cuento
cómo la armé, qué decidí y qué fui ajustando.

Todo sale del network.tf que hoy usa el cluster de producción de
Tiendis. Donde veas algo entre < y >, va el valor de tu cuenta.

El diseño completo

Red de OCI para OKE: Internet entra por el Internet Gateway al NLB y a la API de OKE en la subnet pública; los nodos están en la subnet privada y salen por el NAT Gateway a internet y por el Service Gateway a Object Storage y OCIR

Abrí el diagrama interactivo para
recorrerlo pieza por pieza.

Es una sola VCN (10.20.0.0/16) con dos subnets:

  • Pública (/24): solo el load balancer de entrada y el endpoint de la API de Kubernetes.
  • Privada (/20): los nodos. No tienen IP pública; salen a internet por el NAT y a los servicios de Oracle por el Service Gateway.
resource "oci_core_vcn" "main" {
  compartment_id = var.compartment_ocid
  cidr_blocks    = ["10.20.0.0/16"]
  display_name   = "oke-vcn"
  dns_label      = "oke"
}

resource "oci_core_subnet" "public" {
  compartment_id             = var.compartment_ocid
  vcn_id                     = oci_core_vcn.main.id
  cidr_block                 = cidrsubnet("10.20.0.0/16", 8, 0)   # 10.20.0.0/24
  display_name               = "subnet-public"
  dns_label                  = "public"
  route_table_id             = oci_core_route_table.public.id
  prohibit_public_ip_on_vnic = false
}

resource "oci_core_subnet" "private" {
  compartment_id             = var.compartment_ocid
  vcn_id                     = oci_core_vcn.main.id
  cidr_block                 = cidrsubnet("10.20.0.0/16", 4, 1)   # 10.20.16.0/20
  display_name               = "subnet-private"
  dns_label                  = "private"
  route_table_id             = oci_core_route_table.private.id
  prohibit_public_ip_on_vnic = true
}
Enter fullscreen mode Exit fullscreen mode

Diferencia con AWS: en una VPC cada subnet vive en una zona de disponibilidad, así que
para tener alta disponibilidad terminás con una pública y una privada por AZ, y un NAT
Gateway por zona si no querés que la caída de una se lleve la salida de todas. En OCI las
subnets son regionales: una alcanza para todos los fault domains (y en Santiago, que tiene una
sola AD, para todo el cluster). Son dos subnets en lugar de seis.

Los tres gateways

resource "oci_core_internet_gateway" "igw" {
  compartment_id = var.compartment_ocid
  vcn_id         = oci_core_vcn.main.id
  display_name   = "igw"
}

resource "oci_core_nat_gateway" "nat" {
  compartment_id = var.compartment_ocid
  vcn_id         = oci_core_vcn.main.id
  display_name   = "nat"
}

# "All <región> Services In Oracle Services Network": Object Storage, OCIR, Vault…
data "oci_core_services" "all" {
  filter {
    name   = "name"
    values = ["All .* Services In Oracle Services Network"]
    regex  = true
  }
}

resource "oci_core_service_gateway" "sgw" {
  compartment_id = var.compartment_ocid
  vcn_id         = oci_core_vcn.main.id
  display_name   = "sgw"
  services { service_id = data.oci_core_services.all.services[0]["id"] }
}
Enter fullscreen mode Exit fullscreen mode
  • Internet Gateway: la entrada y salida de la subnet pública.
  • NAT Gateway: la salida de los nodos, para bajar imágenes de Docker Hub o llamar APIs externas, sin que tengan IP pública.
  • Service Gateway: el que más valor me dio. Todo el tráfico hacia los servicios de Oracle (bajar imágenes de OCIR, los backups y las métricas en Object Storage, leer Vault) va por la red interna de Oracle y no pasa por el NAT.

Diferencia con AWS: el NAT Gateway se cobra por hora y por GB procesado, y es fácil que se
lleve una parte importante de la factura sin que nadie lo note. Para que el tráfico a S3 no pase
por ahí está el gateway endpoint de S3 (gratis), pero ECR, Secrets Manager o CloudWatch
necesitan interface endpoints, que se cobran por hora y por zona. En OCI, un solo Service
Gateway cubre todos los servicios de Oracle, y ni él ni el NAT ni el Internet Gateway se cobran.

Las route tables

Una por subnet. La privada tiene dos reglas: lo que va a los servicios de Oracle sale por el
Service Gateway, y todo lo demás por el NAT.

resource "oci_core_route_table" "public" {
  compartment_id = var.compartment_ocid
  vcn_id         = oci_core_vcn.main.id
  display_name   = "rt-public"
  route_rules {
    destination       = "0.0.0.0/0"
    destination_type  = "CIDR_BLOCK"
    network_entity_id = oci_core_internet_gateway.igw.id
  }
}

resource "oci_core_route_table" "private" {
  compartment_id = var.compartment_ocid
  vcn_id         = oci_core_vcn.main.id
  display_name   = "rt-private"
  route_rules {
    destination       = "0.0.0.0/0"
    destination_type  = "CIDR_BLOCK"
    network_entity_id = oci_core_nat_gateway.nat.id
  }
  route_rules {
    destination       = data.oci_core_services.all.services[0]["cidr_block"]
    destination_type  = "SERVICE_CIDR_BLOCK"   # no es un CIDR común: lo resuelve OCI
    network_entity_id = oci_core_service_gateway.sgw.id
  }
}
Enter fullscreen mode Exit fullscreen mode

El SERVICE_CIDR_BLOCK me costó entenderlo: no es un rango de IPs que escribís vos, es una
etiqueta (all-scl-services-in-oracle-services-network) que OCI traduce a las IPs de sus
servicios. Por eso se toma del data y no se escribe a mano.

El 0.0.0.0/0 de las dos tablas asusta un poco la primera vez, pero en una ruta significa
«cualquier destino que no tenga una regla más específica», o sea, la ruta por defecto. Y una ruta
no abre nada: decide por dónde sale el tráfico, no quién puede entrar. En la privada, ese
camino es el NAT, que deja salir a los nodos (a bajar imágenes, por ejemplo) pero no acepta
conexiones que empiecen desde internet. Lo que entra lo deciden las reglas de seguridad de la
sección que sigue.

NSGs: reglas por recurso, no por subnet

OCI tiene dos formas de filtrar tráfico: las security lists, que se aplican a toda una
subnet, y los network security groups (NSG), que se aplican a cada placa de red (VNIC), como
los security groups de AWS. Las dos se suman: un paquete pasa si lo permite cualquiera de las dos.
Casi todas mis reglas están en NSGs, porque así cada pieza tiene solo lo que necesita:

NSG Para qué Reglas de entrada
nsg-cp-endpoint La API de Kubernetes 6443 desde mi IP (allowlist) · 6443 y 12250 desde la VCN, para los nodos
nsg-workers Los nodos Todo el tráfico desde la VCN · los NodePorts del load balancer desde internet
# kubectl desde afuera, solo desde las IPs de la allowlist
resource "oci_core_network_security_group_security_rule" "cp_ext_6443" {
  for_each                  = toset(var.oke_public_endpoint_allowlist)   # ["<tu_ip>/32"]
  network_security_group_id = oci_core_network_security_group.cp_endpoint.id
  direction                 = "INGRESS"
  protocol                  = "6"   # TCP
  source                    = each.value
  source_type               = "CIDR_BLOCK"
  tcp_options {
    destination_port_range {
      min = 6443
      max = 6443
    }
  }
}
Enter fullscreen mode Exit fullscreen mode

El 12250 es el puerto por el que los nodos se comunican con el control plane de OKE; está en la
lista de reglas que pide la documentación de OKE, y fue de las primeras cosas que tuve que abrir.

Los NodePorts abiertos a internet tienen una razón: el load balancer está configurado para
preservar la IP real del cliente, así que los paquetes llegan a los nodos con la IP de origen
de internet, no la del load balancer. Lo cuento en detalle en una próxima entrega, la de la
entrada de tráfico. Como los nodos están en la subnet privada y no tienen IP pública, solo se
llega a esos puertos a través del load balancer.

Security lists: una por subnet, y la default vacía

Cada VCN trae una security list por defecto, y toda subnet que no declara
security_list_ids la usa. Trae egress abierto, algunos mensajes ICMP y el 22 (SSH) abierto a
todo internet, así que conviene no depender de ella: cada subnet declara la suya, con lo mínimo, y
la default queda vacía.

El ICMP no es tráfico de una aplicación: es el protocolo que usa la propia red para avisar
cosas, como «ese destino no existe» o «este paquete es muy grande». El ping usa ICMP, por
ejemplo. No abre ningún puerto, porque no tiene puertos: se filtra por tipo de mensaje (y a veces
por código, un subtipo), y por eso en las reglas aparece como type y code en lugar de un
número de puerto.

En la pública, lo mínimo es la salida, el ICMP y el 80/443 para los load balancers de
entrada. Los creo sin NSG propio, así que esta lista es la que los deja recibir tráfico:

resource "oci_core_security_list" "public" {
  compartment_id = var.compartment_ocid
  vcn_id         = oci_core_vcn.main.id
  display_name   = "sl-public"

  egress_security_rules {
    destination = "0.0.0.0/0"
    protocol    = "all"
  }

  # Los load balancers de entrada no tienen NSG: reciben 80/443 por acá
  dynamic "ingress_security_rules" {
    for_each = toset([80, 443])
    content {
      source   = "0.0.0.0/0"
      protocol = "6"
      tcp_options {
        min = ingress_security_rules.value
        max = ingress_security_rules.value
      }
    }
  }

  # ICMP 3/4 ("fragmentation needed"): sin esto se rompe el path MTU discovery
  ingress_security_rules {
    source   = "0.0.0.0/0"
    protocol = "1"
    icmp_options {
      type = 3
      code = 4
    }
  }
}
Enter fullscreen mode Exit fullscreen mode

La de la subnet privada es igual, sin el 80/443: todo lo que necesitan los nodos ya está en
nsg-workers. El ICMP tipo 3, código 4 va en las dos a propósito. Es el mensaje con el que un
router avisa «este paquete es muy grande, mandalo más chico». Si se bloquea, las conexiones chicas
andan y las grandes se cuelgan sin error, que es de las cosas más difíciles de diagnosticar.

La default no se puede borrar, pero sí se puede tomar con Terraform y dejarla sin reglas. Así, una
subnet que se cree sin declarar su lista no hereda el 22 abierto:

resource "oci_core_default_security_list" "default" {
  manage_default_resource_id = oci_core_vcn.main.default_security_list_id
  display_name               = "sl-default-vacia"
  # sin reglas: ni entrada ni salida
}
Enter fullscreen mode Exit fullscreen mode

Si la VCN ya existe y las subnets usan la default, el orden importa. Primero se suman las listas
nuevas junto a la default (las reglas se suman, así que eso no corta nada). Después se saca la
default de las subnets, y recién al final se vacía. Entre un paso y otro vale la pena probar que
siga entrando tráfico por los load balancers y que los nodos salgan a internet y a Object Storage.

IPs públicas reservadas

La IP del load balancer de entrada tiene que sobrevivir a que se borre y se vuelva a crear el
Service de Kubernetes; si cambia, hay que tocar el DNS. Por eso la creo reservada con
Terraform y el load balancer la toma por anotación:

resource "oci_core_public_ip" "ingress_prd" {
  compartment_id = var.compartment_ocid
  lifetime       = "RESERVED"
  display_name   = "ingress-prd-nlb"

  # La asigna el cloud controller de OKE al NLB: Terraform no tiene que pelear por eso
  lifecycle {
    ignore_changes = [private_ip_id]
  }
}
Enter fullscreen mode Exit fullscreen mode
metadata:
  annotations:
    oci.oraclecloud.com/load-balancer-type: "nlb"
    oci.oraclecloud.com/reserved-ips: "<ip_reservada>"
Enter fullscreen mode Exit fullscreen mode

El ignore_changes es clave: sin él, cada terraform plan quiere desasociar la IP del load
balancer, porque fue el cloud controller de OKE el que la asoció, no Terraform.

Diferencia con AWS: es el equivalente a una Elastic IP. En AWS, desde 2024, toda IPv4
pública se cobra por hora
, esté en uso o no. En OCI, la IP reservada no tiene costo.

La red de los pods: flannel

El CNI es la pieza que le da una dirección IP a cada pod y hace que los pods se encuentren entre
sí. OKE ofrece dos:

  • VCN-native: cada pod recibe una IP real de la subnet, como si fuera una máquina más de la red (es lo que hace el VPC CNI de EKS).
  • flannel: Kubernetes arma una red propia "por arriba" de la de OCI. Los pods tienen direcciones de un rango aparte, 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.

Elegí flannel:

resource "oci_containerengine_cluster" "oke" {
  # …
  cluster_pod_network_options {
    cni_type = "FLANNEL_OVERLAY"
  }
  options {
    kubernetes_network_config {
      pods_cidr     = "10.244.0.0/16"
      services_cidr = "10.96.0.0/16"
    }
  }
}
Enter fullscreen mode Exit fullscreen mode

Lo que pesó en la decisión: con flannel los pods no consumen IPs de la VCN, así que no tuve
que dimensionar la subnet pensando en cuántos pods entran por nodo, que con el VPC CNI de EKS es
un límite real. Los rangos de pods y servicios solo tienen que no pisarse con el de la VCN.

El costo de esa decisión lo descubrí después: flannel no aplica NetworkPolicies. Kubernetes
las acepta y las guarda, pero nadie las hace cumplir. Si las necesitás de verdad, se puede sumar
Calico en modo policy-only encima de flannel, o elegir VCN-native desde el principio. Es una de
las cosas que tengo anotadas para revisar en mi cluster.

Resumen: lo mismo en AWS y en OCI

Tema AWS OCI
Subnets Por zona: una pública y una privada por AZ Regionales: una pública y una privada para todo
Salida a internet NAT Gateway por AZ, por hora y por GB NAT Gateway sin cargo
Servicios del proveedor Gateway endpoint de S3 + interface endpoints pagos Un Service Gateway para todo, sin cargo
Filtrado Security groups (y NACLs) NSGs (y security lists)
IP fija de entrada Elastic IP, con cargo por hora IP reservada, sin cargo
Red de pods VPC CNI (IPs de la VPC) VCN-native o flannel (overlay)

Lo que viene

En la parte 4 va el cluster y los node pools: OKE
Basic, nodos Ampere A1 repartidos en fault domains y el cluster-autoscaler.

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)