15 min de lectura

Objetivos de aprendizaje

Al final de este módulo, podrás:

  • Definir Network Security Groups y sus reglas con `ionoscloud_nsg` y `ionoscloud_nsg_firewallrule`, y adjuntarlos a las NIC de los servidores
  • Aprovisionar un Managed Application Load Balancer con `ionoscloud_application_loadbalancer`, una regla de reenvío y un grupo de destinos
  • Configurar en código la enrutación HTTP basada en rutas y las comprobaciones de estado para la API de TaskBoard
  • Aprovisionar un Managed Network Load Balancer con `ionoscloud_networkloadbalancer` y elegir entre NLB y ALB
  • Proteger los servidores con equilibrio de carga mediante reglas a nivel de NIC que admitan únicamente la dirección privada del equilibrador de carga

Unidad 2.3: Equilibrio de carga y seguridad como código

Introducción

La red de TaskBoard de la Unidad 2.2 separa las capas, pero cualquier elemento dentro de la LAN de la aplicación aún puede acceder a todos los puertos del servidor de API, y los clientes siguen conectándose a un solo servidor. Antes de agregar un segundo servidor de API, necesita un Load Balancer delante de la API y reglas de firewall que pueda revisar en una solicitud de extracción (pull request).

En esta unidad, escribe ambos componentes como código. Los Network Security Groups (NSG) contienen reglas de firewall con estado que se aplican a servidores y tarjetas de interfaz de red (NIC). El Managed Application Load Balancer (ALB) enruta las solicitudes HTTP por ruta hacia grupos de destino con comprobaciones de estado de salud, y el Managed Network Load Balancer (NLB) distribuye el tráfico TCP. Ambos Load Balancer son recursos de Terraform independientes que usted aprovisiona por separado de los servidores que se encuentran detrás de ellos. En el laboratorio de código, coloca un ALB delante de la API de TaskBoard y restringe la capa de aplicación mediante un NSG.

1. Network Security Groups como código

resource "ionoscloud_nsg" "app" {
  datacenter_id = ionoscloud_datacenter.taskboard.id
  name          = "taskboard-app"
  description   = "App tier: HTTP from the ALB only"
}

resource "ionoscloud_nsg_firewallrule" "app_http_from_alb" {
  datacenter_id    = ionoscloud_datacenter.taskboard.id
  nsg_id           = ionoscloud_nsg.app.id
  name             = "http-from-alb"
  type             = "INGRESS"
  protocol         = "TCP"
  source_ip        = "10.10.1.6"
  port_range_start = 80
  port_range_end   = 80
}

resource "ionoscloud_nsg_firewallrule" "app_egress" {
  datacenter_id = ionoscloud_datacenter.taskboard.id
  nsg_id        = ionoscloud_nsg.app.id
  name          = "egress-all"
  type          = "EGRESS"
  protocol      = "ANY"
}

Un NSG tiene una configuración predeterminada de denegar todo: las reglas solo permiten el tráfico, y cualquier tráfico que no se haya permitido explícitamente se bloquea. Esto se aplica a ambas direcciones, por lo que el ejemplo también añade una regla de salida. Los firewalls de NSG son con estado, por lo que las respuestas a una conexión permitida pasan sin necesidad de una regla propia.

1.1 Argumentos de la regla

Argumento Obligatorio Notas
nsg_id, datacenter_id Sí El NSG y su VDC
protocol Sí TCP, UDP, ICMP o ANY; cambiarlo obliga a crear una nueva regla
type No INGRESS (predeterminado) o EGRESS
source_ip, target_ip No Una dirección IPv4 cada uno; null permite todas
port_range_start, port_range_end No Para TCP y UDP; deje ambos en null para permitir todos los puertos
icmp_type, icmp_code No Solo para ICMP

Como muestra la tabla, una regla coincide con una única dirección de origen. Para un nivel con varios clientes, escriba una regla por cliente, o genérelos con for_each:

resource "ionoscloud_nsg_firewallrule" "db_from_app" {
  for_each         = toset(["10.10.2.11", "10.10.2.21"]) # DB-LAN NICs, Unit 2.5
  datacenter_id    = ionoscloud_datacenter.taskboard.id
  nsg_id           = ionoscloud_nsg.db.id
  name             = "pg-from-${each.value}"
  protocol         = "TCP"
  source_ip        = each.value
  port_range_start = 5432
  port_range_end   = 5432
}

1.2 Adjuntar NSGs a servidores y NICs

Las NICs y las VMs pueden ser miembros de un NSG. Cuando una VM es miembro, todas sus NICs heredan las reglas. Para proteger únicamente la interfaz de la capa de aplicaciones del servidor de API, adjunte el NSG a esa NIC:

resource "ionoscloud_nic" "api_app" {
  datacenter_id       = ionoscloud_datacenter.taskboard.id
  server_id           = ionoscloud_server.api.id
  lan                 = ionoscloud_lan.app.id
  name                = "app"
  dhcp                = true
  ips                 = ["10.10.1.11"]
  firewall_active     = false
  security_groups_ids = [ionoscloud_nsg.app.id]
}

ionoscloud_server y ionoscloud_vcpu_server aceptan el mismo argumento security_groups_ids para la membresía a nivel de servidor. Un VDC puede tener un NSG predeterminado, vinculado con ionoscloud_datacenter_nsg_selection; cada VM recién aprovisionada se agrega a él automáticamente.

1.3 Límites y alcance de NSG

Los valores predeterminados son 200 NSGs por VDC, 100 reglas por NSG y 10 NSGs por VM o por NIC. No puede agregar nodos de los grupos de nodos de Managed Kubernetes ni Cubes en suspensión como miembros. Los miembros de un NSG son NICs y VMs, por lo que un NSG se vincula a los servidores detrás de un equilibrador de carga, nunca al ALB o NLB en sí (sección 4).

El firewall basado en NIC utiliza el recurso ionoscloud_firewall y la bandera firewall_active en una NIC. No se recomienda utilizar NSGs en paralelo con un firewall basado en NIC, por lo que la NIC anterior establece firewall_active = false.

2. El Managed Application Load Balancer

El ALB opera en la capa 7. Cada ALB requiere al menos un listener, una regla de reenvío y un grupo de destino. Un listener acepta conexiones de clientes en una IP y un puerto; las reglas de reenvío determinan cómo llegan las solicitudes a los destinos registrados.

2.1 Load Balancer y grupo de destino

resource "ionoscloud_ipblock" "alb" {
  name     = "taskboard-alb-ip"
  location = ionoscloud_datacenter.taskboard.location
  size     = 1
}

resource "ionoscloud_application_loadbalancer" "api" {
  datacenter_id  = ionoscloud_datacenter.taskboard.id
  name           = "taskboard-alb"
  listener_lan   = ionoscloud_lan.public.id
  ips            = [ionoscloud_ipblock.alb.ips[0]]
  target_lan     = ionoscloud_lan.app.id
  lb_private_ips = ["10.10.1.6/24"]
}

resource "ionoscloud_target_group" "api" {
  name             = "taskboard-api"
  algorithm        = "ROUND_ROBIN"
  protocol         = "HTTP"
  protocol_version = "HTTP1"

  targets {
    ip     = "10.10.1.11"
    port   = 80
    weight = 100
  }

  health_check {
    check_interval = 2000
    retries        = 3
  }
  http_health_check {
    path       = "/health"
    method     = "GET"
    match_type = "STATUS_CODE"
    response   = "200"
  }
}

Un ALB público requiere IPs públicas reservadas por el cliente en la LAN del listener, por lo que ips proviene de un bloque de IP. target_lan es la LAN privada equilibrada, y lb_private_ips es la propia dirección del ALB en ella, con una máscara de subred. Si se omite, el sistema genera una IP con una subred /24. Una dirección fija del rango de managed-services (Unidad 2.2, Sección 1.3) le permite escribir reglas de NSG contra ella.

Los pesos de destino van de 0 a 256. Un destino con peso 0 no recibe tráfico equilibrado, pero sigue aceptando conexiones persistentes. El intervalo de verificación de estado predeterminado es de 2000 ms con 3 reintentos, y el valor predeterminado de path para la verificación de estado HTTP es /.

2.2 Reglas de reenvío y enrutamiento basado en rutas

resource "ionoscloud_application_loadbalancer_forwardingrule" "http" {
  datacenter_id               = ionoscloud_datacenter.taskboard.id
  application_loadbalancer_id = ionoscloud_application_loadbalancer.api.id
  name                        = "http"
  protocol                    = "HTTP"
  listener_ip                 = ionoscloud_ipblock.alb.ips[0]
  listener_port               = 80

  http_rules {
    name         = "api"
    type         = "FORWARD"
    target_group = ionoscloud_target_group.api.id
    conditions {
      type      = "PATH"
      condition = "STARTS_WITH"
      value     = "/api"
    }
  }

  http_rules {
    name             = "default"
    type             = "STATIC"
    status_code      = 404
    response_message = "Not found"
    content_type     = "text/plain"
  }
}

Una regla FORWARD requiere un target_group. Las condiciones pueden coincidir con HEADER, PATH, QUERY, METHOD, HOST, COOKIE o SOURCE_IP, y la acción se ejecuta solo si se cumple cada condición. Una regla sin condiciones se aplica siempre, por lo que la regla STATIC devuelve un 404 fijo para cada otra ruta. Las reglas REDIRECT envían a los clientes a otro lugar con estado 301, 302, 303, 307 o 308.

Para HTTPS, mantenga protocol = "HTTP" y pase los identificadores de certificado en server_certificates; el ALB termina entonces TLS. Un ALB admite hasta 10 listeners, y client_timeout tiene un valor predeterminado de 50.000 ms.

3. El Managed Network Load Balancer

# ionoscloud_ipblock.nlb: a one-address block, like ionoscloud_ipblock.alb
resource "ionoscloud_networkloadbalancer" "tcp" {
  datacenter_id  = ionoscloud_datacenter.taskboard.id
  name           = "taskboard-nlb"
  listener_lan   = ionoscloud_lan.public.id
  ips            = [ionoscloud_ipblock.nlb.ips[0]]
  target_lan     = ionoscloud_lan.app.id
  lb_private_ips = ["10.10.1.7/24"]
}

resource "ionoscloud_networkloadbalancer_forwardingrule" "ws" {
  datacenter_id          = ionoscloud_datacenter.taskboard.id
  networkloadbalancer_id = ionoscloud_networkloadbalancer.tcp.id
  name                   = "websocket"
  algorithm              = "SOURCE_IP"
  protocol               = "TCP"
  listener_ip            = ionoscloud_ipblock.nlb.ips[0]
  listener_port          = 443

  targets {
    ip     = "10.10.1.11"
    port   = 8443
    weight = 1
    health_check {
      check          = true
      check_interval = 2000
    }
  }
}

El NLB tiene el mismo modelo de LAN de listener y LAN de destino, pero sus reglas y comprobaciones de estado son solo TCP. Los valores predeterminados de la comprobación de estado son un tiempo de espera de cliente de 50.000 ms, un tiempo de espera de conexión de 5.000 ms, un tiempo de espera de destino de 50.000 ms y 3 reintentos.

3.1 ¿NLB o ALB?

Necesidad Elección
Enrutamiento por ruta, encabezado, host, consulta o cookie ALB
Respuestas fijas o redirecciones sin un backend ALB
Terminación TLS con certificados en el equilibrador de carga ALB
Cualquier protocolo TCP, decidido solo en la capa 4 NLB
Persistencia de cliente por IP de origen NLB con SOURCE_IP

Si su lógica de equilibrado necesita solicitudes HTTP y sus atributos, use el ALB. Si el rendimiento del enrutamiento es crítico, mantenga la lógica en la capa 4 y enrute el tráfico TCP a través del NLB. TaskBoard utiliza el ALB para su API REST.

4. Protección de niveles con balanceo de carga

4.1 Dónde se aplican las reglas

Las reglas de NSG se vinculan a las NIC de los servidores de la LAN de destino, no al balanceador de carga. Por lo tanto, protege un servicio con ALB desde el lado de destino:

  1. Asigne a ALB una dirección lb_private_ips fija, por ejemplo, 10.10.1.6.
  2. Permita el puerto del servicio en la NIC de destino solo desde esa dirección (sección 1).
  3. No proporcione a los destinos una NIC pública, o mantenga la NIC pública fuera de la ruta del servicio.
locals {
  alb_private_ip = "10.10.1.6"
}
# In the ALB:      lb_private_ips = ["${local.alb_private_ip}/24"]
# In the NSG rule: source_ip      = local.alb_private_ip

Un valor local mantiene sincronizadas la dirección del ALB y la regla del NSG. En el laboratorio de esta unidad, el servidor de API conserva su NIC pública para SSH; en producción, elimínela y acceda al servidor a través de la VPN (Unidad 2.2).

4.2 Tráfico saliente desde los destinos

Ni el ALB ni el NLB admiten Source NAT (SNAT): los destinos no pueden iniciar conexiones de red a través del balanceador de carga. Los servidores ubicados detrás del balanceador de carga que necesiten descargar paquetes o llamar a APIs externas utilizan el Managed NAT Gateway y la ruta de la Unidad 2.2. La regla de egreso del NSG de la Sección 1 también debe permitir ese tráfico.

Tarjeta rápida de referencia de la API

Endpoints principales de la API detrás de los recursos de esta unidad:

Método Endpoint Descripción
POST /datacenters/{datacenterId}/securitygroups Creado por ionoscloud_nsg
POST /datacenters/{datacenterId}/securitygroups/{securityGroupId}/rules Creado por ionoscloud_nsg_firewallrule
PUT /datacenters/{datacenterId}/servers/{serverId}/nics/{nicId}/securitygroups Establece los NSG de una NIC
POST /datacenters/{datacenterId}/applicationloadbalancers Creado por ionoscloud_application_loadbalancer
POST /targetgroups Creado por ionoscloud_target_group

URL base: https://api.ionos.com/cloudapi/v6 Autenticación: Authorization: Bearer <token>

Laboratorio de código

Objetivo: Aprovisionar un ALB delante de la API de TaskBoard con Terraform, adjuntar un NSG a la NIC de la aplicación del servidor de la API y verificar que el tráfico HTTP llegue a la API solo a través del ALB.

Requisitos previos:

  • El proyecto de red de la Unidad 2.2, aplicado, con IONOS_TOKEN configurado
  • Terraform con el proveedor fijado como en la Unidad 1.2
  • El servidor de la API sirviendo HTTP en el puerto 80 (cloud-init de la Unidad 2.1)

Paso 1: Agregar un endpoint de salud al servidor de la API

Extienda la configuración cloud-config del servidor de la API para que nginx devuelva 200 para /health y /api/ (por ejemplo, con write_files y dos bloques location). Dado que user_data se aplica solo a nuevos volúmenes, reconstruya el servidor:

terraform apply -replace=ionoscloud_server.api -auto-approve | tail -n 1

Salida esperada:

Apply complete! Resources: ... added, 0 changed, ... destroyed.

Paso 2: Agregar el NSG y sus reglas

Agregue ionoscloud_nsg.app y ambas reglas de la Sección 1, y establezca firewall_active = false y security_groups_ids en ionoscloud_nic.api_app (Sección 1.2).

terraform plan | grep -E "will be (created|updated)"

Salida esperada:

  # ionoscloud_nic.api_app will be updated in-place
  # ionoscloud_nsg.app will be created
  # ionoscloud_nsg_firewallrule.app_egress will be created
  # ionoscloud_nsg_firewallrule.app_http_from_alb will be created

Paso 3: Agregar el ALB, el grupo de destinos y la regla de reenvío

Agregue los recursos de las secciones 2.1 y 2.2, además de una salida:

output "alb_ip" { value = ionoscloud_ipblock.alb.ips[0] }
terraform apply -auto-approve | tail -n 1

Salida esperada:

Apply complete! Resources: 7 added, 1 changed, 0 destroyed.

Paso 4: Verificar el ALB a través de la API

DC=$(terraform output -raw datacenter_id)
curl -s -H "Authorization: Bearer $IONOS_TOKEN" \
  "https://api.ionos.com/cloudapi/v6/datacenters/$DC/applicationloadbalancers?depth=1" \
  | jq -r '.items[] | "\(.properties.name) \(.metadata.state)"'

Salida esperada:

taskboard-alb AVAILABLE

Paso 5: Verificar la enrutación a través del ALB

ALB=$(terraform output -raw alb_ip)
curl -s -o /dev/null -w "%{http_code}\n" "http://$ALB/api/"
curl -s -o /dev/null -w "%{http_code}\n" "http://$ALB/other"

Salida esperada:

200
404

Paso 6: Verificar el aislamiento dentro de la LAN de la aplicación

ssh -J root@"$(terraform output -raw api_public_ip)" root@10.10.1.21 \
  'curl -s --max-time 5 -o /dev/null -w "%{http_code}\n" http://10.10.1.11/api/ || echo blocked'

Salida esperada:

000
blocked

El worker se encuentra en la misma LAN, pero el NSG en la NIC de la aplicación del servidor de API admite el puerto 80 solo desde la dirección del ALB 10.10.1.6.

Lista de verificación de validación:

  • [ ] El ALB es AVAILABLE con la IP pública reservada
  • [ ] /api/ devuelve 200 a través del ALB y otras rutas devuelven el 404 estático
  • [ ] El worker no puede alcanzar directamente el puerto 80 del servidor de API
  • [ ] terraform plan no muestra cambios después de la aplicación

Limpieza:

terraform destroy -auto-approve

Errores comunes

Errores de desarrollo a evitar con el tema de esta unidad:

  1. Todo el tráfico se bloquea después de adjuntar un NSG

    • Problema: En cuanto se adjunta el NSG, el servidor deja de responder y no puede alcanzar la pasarela NAT ni la base de datos.
    • Por qué ocurre: Los NSG deniegan todo el tráfico que ninguna regla permita, en ambas direcciones.
    • Solución: Agregue reglas explícitas de EGRESS para el tráfico saliente que el servidor necesita, y reglas de INGRESS para cada dirección y puerto de cliente.
  2. Esperar que el NSG proteja el balanceador de carga

    • Problema: Usted adjunta un NSG al ALB en un documento de diseño, y el plan de Terraform no tiene un lugar para colocarlo.
    • Por qué ocurre: Los miembros de un NSG son NICs y VMs. El listener del balanceador de carga no es un miembro.
    • Solución: Filtre en las NICs de destino, con reglas que permitan solo la dirección fija de lb_private_ips del balanceador de carga (Sección 4.1).
  3. Las comprobaciones de estado marcan todos los destinos como caídos

    • Problema: El ALB devuelve errores aunque el servidor de la API esté en ejecución.
    • Por qué ocurre: La comprobación de estado HTTP solicita una ruta que la aplicación no sirve, o el NSG bloquea la comprobación de estado desde la dirección privada del ALB.
    • Solución: Apunte http_health_check.path a un endpoint que devuelva el response configurado, y permita la IP privada del ALB en el puerto del servicio.

Resumen

Ahora puede colocar la API de TaskBoard detrás de un equilibrador de carga y protegerla mediante código. Los NSG contienen reglas con estado y de denegación por defecto que se adjuntan a servidores o NIC. El ALB conecta una LAN de escucha pública con una LAN de destino privada, enruta las solicitudes HTTP por ruta hacia grupos de destino con comprobaciones de estado y puede devolver respuestas fijas. El NLB cubre el equilibrado solo de TCP, y el límite de seguridad siempre se encuentra en las NIC de destino.

Puntos clave:

  • Las reglas de NSG solo permiten el tráfico; todo lo demás se bloquea en ambas direcciones, y se permiten las respuestas (con estado)
  • Los miembros de un NSG son NIC y VM; no utilice NSG en paralelo con el firewall basado en NIC
  • Un ALB requiere un escucha, una regla de reenvío y un grupo de destino; las escucha públicas requieren IP reservadas
  • Utilice el ALB para el enrutado de HTTP y la terminación de TLS, y el NLB para el equilibrado de TCP de capa 4
  • Ningún equilibrador de carga admite SNAT; los destinos utilizan la pasarela NAT para el tráfico saliente

Terminología importante:

  • Network Security Group (NSG): Un conjunto de reglas de permiso con estado aplicadas a las NIC o VM miembros en un VDC
  • LAN de escucha: La LAN donde un equilibrador de carga acepta conexiones de clientes
  • LAN de destino: La LAN privada donde un equilibrador de carga alcanza sus destinos a través de lb_private_ips
  • Grupo de destino: Un conjunto reutilizable de destinos de ALB con un algoritmo y comprobaciones de estado
  • Regla de reenvío: La configuración del escucha que asigna una IP y un puerto a destinos, con reglas de HTTP en un ALB

Próximos pasos

Siga aprendiendo: Unidad 2.4: Almacenamiento como código

Temas relacionados: