~ / posts / oci-kubernetes / red-oci-para-oke.md
2026-11-19 · 11 min de lectura

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

Cómo armé la red del cluster en OCI con Terraform: VCN, subnets regionales, Internet, NAT y Service Gateway, route tables, NSGs, IPs reservadas y la red de pods con flannel. Y por qué en AWS esta parte pesa tanto en la factura.

tiendisterraformocikubernetesawsnetworking

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

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.

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:

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
}

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"] }
}

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

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

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

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
}

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]
  }
}
metadata:
  annotations:
    oci.oraclecloud.com/load-balancer-type: "nlb"
    oci.oraclecloud.com/reserved-ips: "<ip_reservada>"

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:

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"
    }
  }
}

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.

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