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:
- Asigne a ALB una dirección
lb_private_ipsfija, por ejemplo,10.10.1.6. - Permita el puerto del servicio en la NIC de destino solo desde esa dirección (sección 1).
- 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_TOKENconfigurado - 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
AVAILABLEcon 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 planno 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:
-
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
EGRESSpara el tráfico saliente que el servidor necesita, y reglas deINGRESSpara cada dirección y puerto de cliente.
-
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_ipsdel balanceador de carga (Sección 4.1).
-
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.patha un endpoint que devuelva elresponseconfigurado, 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: