Einheit 2.3: Lastverteilung und Sicherheit als Code
Einführung
Das Netzwerk von TaskBoard aus Einheit 2.2 trennt die Ebenen, aber alles innerhalb des App-LAN kann weiterhin jeden Port des API-Servers erreichen, und Clients verbinden sich weiterhin mit einem einzelnen Server. Bevor Sie einen zweiten API-Server hinzufügen, benötigen Sie einen Load Balancer vor der API sowie Firewall-Regeln, die Sie in einem Pull Request überprüfen können.
In dieser Einheit schreiben Sie beides als Code. Network Security Groups (NSGs) enthalten zustandsbehaftete Firewall-Regeln, die auf Server und NICs angewendet werden. Der Managed Application Load Balancer (ALB) leitet HTTP-Anfragen nach Pfad an Zielgruppen mit Health Checks weiter, und der Managed Network Load Balancer (NLB) verteilt TCP-Verkehr. Beide Load Balancer sind eigene Terraform-Ressourcen, die Sie separat von den Servern dahinter provisionieren. Im Code Lab setzen Sie einen ALB vor die API von TaskBoard und sichern die App-Ebene mit einer NSG ab.
1. Network Security Groups als Code
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"
}
Eine NSG hat eine Standardregel „alles ablehnen": Regeln erlauben nur den Datenverkehr, und jeder Datenverkehr, der nicht ausdrücklich erlaubt ist, wird blockiert. Das gilt für beide Richtungen, weshalb das Beispiel auch eine Egress-Regel hinzufügt. NSG-Firewalls sind zustandsbehaftet, sodass Antworten auf eine erlaubte Verbindung ohne eigene Regel durchgelassen werden.
1.1 Argumente der Regel
| Argument | Erforderlich | Hinweise |
|---|---|---|
nsg_id, datacenter_id |
Ja | Die NSG und ihr VDC |
protocol |
Ja | TCP, UDP, ICMP oder ANY; eine Änderung erzwingt eine neue Regel |
type |
Nein | INGRESS (Standard) oder EGRESS |
source_ip, target_ip |
Nein | Jeweils eine IPv4-Adresse; null erlaubt alle |
port_range_start, port_range_end |
Nein | Für TCP und UDP; beide auf null lassen, um alle Ports zu erlauben |
icmp_type, icmp_code |
Nein | Nur für ICMP |
Wie die Tabelle zeigt, entspricht eine Regel einer einzelnen Quelladresse. Für eine Ebene mit mehreren Clients schreiben Sie eine Regel pro Client oder generieren Sie sie mit 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 Zuordnung von NSGs zu Servern und NICs
NICs und VMs können Mitglieder einer NSG sein. Wenn eine VM Mitglied ist, erben alle ihre NICs die Regeln. Um nur die App-Tier-Schnittstelle des API-Servers zu schützen, ordnen Sie die NSG dieser NIC zu:
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 und ionoscloud_vcpu_server akzeptieren dasselbe security_groups_ids-Argument für serverweite Mitgliedschaft. Ein VDC kann eine Standard-NSG besitzen, die mit ionoscloud_datacenter_nsg_selection verknüpft ist; jede neu bereitgestellte VM wird automatisch hinzugefügt.
1.3 NSG-Limits und Geltungsbereich
Die Standardwerte betragen 200 NSGs pro VDC, 100 Regeln pro NSG und 10 NSGs pro VM oder pro NIC. Es ist nicht möglich, Knoten aus Managed Kubernetes-Knotenpools oder aus suspendierten Cubes als Mitglieder hinzuzufügen. NSG-Mitglieder sind NICs und VMs, daher bindet eine NSG an die Server hinter einem Load Balancer, niemals an den ALB oder NLB selbst (Abschnitt 4).
Die NIC-basierte Firewall verwendet die ionoscloud_firewall-Ressource und die firewall_active-Schaltfläche an einer NIC. Der parallele Einsatz von NSGs mit einer NIC-basierten Firewall wird nicht empfohlen, weshalb die oben genannte NIC firewall_active = false setzt.
2. Der Managed Application Load Balancer
Der ALB arbeitet auf Layer 7. Jeder ALB benötigt mindestens einen Listener, eine Weiterleitungsregel und eine Zielgruppe. Ein Listener nimmt Client-Verbindungen an einer IP und einem Port an; Weiterleitungsregeln bestimmen, wie Anfragen die registrierten Ziele erreichen.
2.1 Load Balancer und Zielgruppe
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"
}
}
Ein öffentlicher ALB benötigt kundenspezifisch reservierte öffentliche IP-Adressen im Listener-LAN, daher stammt ips aus einem IP-Block. target_lan ist das balancierte private LAN, und lb_private_ips ist die eigene Adresse des ALB darin, mit einer Subnetzmaske. Wenn Sie sie weglassen, generiert das System eine IP-Adresse mit einer /24-Subnetzmaske. Eine feste Adresse aus dem Bereich für verwaltete Dienste (Einheit 2.2, Abschnitt 1.3) ermöglicht es, NSG-Regeln dagegen zu definieren.
Die Zielgewichte liegen im Bereich von 0 bis 256. Ein Ziel mit dem Gewicht 0 erhält keinen balancierten Traffic, akzeptiert jedoch weiterhin persistente Verbindungen. Das Intervall der Health Checks beträgt standardmäßig 2000 ms mit 3 Wiederholungen, und der HTTP-Health-Check path hat standardmäßig den Wert /.
2.2 Weiterleitungsregeln und pfadbasierte Routing
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"
}
}
Eine FORWARD-Regel benötigt ein target_group. Bedingungen können auf HEADER, PATH, QUERY, METHOD, HOST, COOKIE oder SOURCE_IP prüfen, und die Aktion wird nur ausgeführt, wenn alle Bedingungen erfüllt sind. Eine Regel ohne Bedingungen wird immer angewendet, daher liefert die STATIC-Regel für jeden anderen Pfad einen festen 404-Fehler. REDIRECT-Regelen leiten Clients mit dem Status 301, 302, 303, 307 oder 308 an einen anderen Ort weiter.
Für HTTPS, halten Sie protocol = "HTTP" bei und übergeben Sie Zertifikats-IDs in server_certificates; der ALB beendet dann TLS. Ein ALB unterstützt bis zu 10 Listener, und client_timeout ist standardmäßig auf 50.000 ms festgelegt.
3. Der 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
}
}
}
Der NLB verwendet dasselbe Modell für das Listener-LAN und das Ziel-LAN, seine Regeln und Health Checks sind jedoch ausschließlich TCP-basiert. Die Standardwerte für Health Checks sind eine Client-Timeout von 50.000 ms, eine Verbindungs-Timeout von 5.000 ms, eine Ziel-Timeout von 50.000 ms und 3 Wiederholungen.
3.1 NLB oder ALB?
| Anforderung | Empfehlung |
|---|---|
| Routing nach Pfad, Header, Host, Abfrage oder Cookie | ALB |
| Feste Antworten oder Weiterleitungen ohne Backend | ALB |
| TLS-Terminierung mit Zertifikaten auf dem Load Balancer | ALB |
| Beliebiges TCP-Protokoll, Entscheidung nur auf Ebene 4 | NLB |
| Client-Stickiness anhand der Quell-IP | NLB mit SOURCE_IP |
Wenn Ihre Balancing-Logik HTTP-Anfragen und deren Attribute benötigt, verwenden Sie den ALB. Wenn die Routing-Leistung entscheidend ist, halten Sie die Logik auf Ebene 4 und leiten Sie TCP-Verkehr über den NLB. TaskBoard verwendet den ALB für seine REST API.
4. Absichern von Lastverteilungs-Ebenen
4.1 Wo die Regeln greifen
NSG-Regeln werden den NICs der Server im Ziel-LAN zugewiesen, nicht dem Load Balancer. Sie sichern daher einen von einem ALB frontenden Dienst von der Zielseite aus:
- Weisen Sie dem ALB eine feste
lb_private_ips-Adresse zu, beispielsweise10.10.1.6. - Erlauben Sie den Dienstport auf der Ziel-NIC nur von dieser Adresse (Abschnitt 1).
- Vergeben Sie für die Zielsysteme keine öffentliche NIC oder halten Sie die öffentliche NIC außerhalb des Dienstpfads.
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
Ein lokaler Wert hält die ALB-Adresse und die NSG-Regel synchron. Im Labor dieser Einheit behält der API-Server seine öffentliche NIC für SSH; in der Produktion wird sie entfernt und der Server wird über das VPN (Einheit 2.2) erreicht.
4.2 Ausgehender Traffic von Zielen
Weder der ALB noch der NLB unterstützt Source NAT (SNAT): Ziele können keine Netzwerkverbindungen über den Load Balancer initiieren. Server hinter dem Load Balancer, die Pakete herunterladen oder externe APIs aufrufen müssen, verwenden das Managed NAT Gateway und die Route aus Einheit 2.2. Die NSG-Egress-Regel aus Abschnitt 1 muss diesen Traffic ebenfalls zulassen.
API-Referenz Schnellkarte
Wichtige API-Endpunkte hinter den Ressourcen dieser Einheit:
| Methode | Endpunkt | Beschreibung |
|---|---|---|
POST |
/datacenters/{datacenterId}/securitygroups |
Erstellt von ionoscloud_nsg |
POST |
/datacenters/{datacenterId}/securitygroups/{securityGroupId}/rules |
Erstellt von ionoscloud_nsg_firewallrule |
PUT |
/datacenters/{datacenterId}/servers/{serverId}/nics/{nicId}/securitygroups |
Setzt die NSGs einer NIC |
POST |
/datacenters/{datacenterId}/applicationloadbalancers |
Erstellt von ionoscloud_application_loadbalancer |
POST |
/targetgroups |
Erstellt von ionoscloud_target_group |
Basis-URL: https://api.ionos.com/cloudapi/v6
Authentifizierung: Authorization: Bearer <token>
Code Lab
Ziel: Eine ALB vor der API von TaskBoard mit Terraform bereitstellen, eine NSG an die App-NIC des API-Servers anbinden und sicherstellen, dass HTTP-Verkehr die API nur über die ALB erreicht.
Voraussetzungen:
- Das Netzwerkprojekt aus Einheit 2.2, angewendet, mit
IONOS_TOKENfestgelegt - Terraform mit dem Provider, wie in Einheit 1.2 festgelegt
- Der API-Server, der HTTP auf Port 80 bereitstellt (cloud-init aus Einheit 2.1)
Schritt 1: Einen Health-Endpoint zum API-Server hinzufügen
Erweitern Sie die cloud-config des API-Servers, sodass nginx für /health und /api/ den Status 200 zurückgibt (zum Beispiel mit write_files und zwei location-Blöcken). Da user_data nur auf neue Volumes zutrifft, bauen Sie den Server neu auf:
terraform apply -replace=ionoscloud_server.api -auto-approve | tail -n 1
Erwartete Ausgabe:
Apply complete! Resources: ... added, 0 changed, ... destroyed.
Schritt 2: NSG und ihre Regeln hinzufügen
Fügen Sie ionoscloud_nsg.app sowie beide Regeln aus Abschnitt 1 hinzu und setzen Sie firewall_active = false und security_groups_ids auf ionoscloud_nic.api_app (Abschnitt 1.2).
terraform plan | grep -E "will be (created|updated)"
Erwartete Ausgabe:
# 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
Schritt 3: ALB, Zielgruppe und Weiterleitungsregel hinzufügen
Fügen Sie die Ressourcen aus den Abschnitten 2.1 und 2.2 sowie eine Ausgabe hinzu:
output "alb_ip" { value = ionoscloud_ipblock.alb.ips[0] }
terraform apply -auto-approve | tail -n 1
Erwartete Ausgabe:
Apply complete! Resources: 7 added, 1 changed, 0 destroyed.
Schritt 4: ALB über die API prüfen
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)"'
Erwartete Ausgabe:
taskboard-alb AVAILABLE
Schritt 5: Routing über den ALB überprüfen
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"
Erwartete Ausgabe:
200
404
Schritt 6: Isolation im App-LAN überprüfen
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'
Erwartete Ausgabe:
000
blocked
Der Worker befindet sich im selben LAN, aber die NSG auf der App-NIC des API-Servers lässt Port 80 nur von der Adresse 10.10.1.6 des ALB zu.
Prüfliste:
- [ ] Der ALB ist
AVAILABLEmit der reservierten öffentlichen IP - [ ]
/api/gibt 200 über den ALB zurück, während andere Pfade die statische 404 zurückgeben - [ ] Der Worker kann Port 80 des API-Servers nicht direkt erreichen
- [ ]
terraform planzeigt nach dem Apply keine Änderungen
Aufräumarbeiten:
terraform destroy -auto-approve
Häufige Fehler
Fehler von Entwicklerinnen und Entwicklern, die bei diesem Thema der Einheit vermieden werden sollten:
-
Gesamter Verkehr wird nach dem Anhängen einer NSG blockiert
- Problem: Sobald die NSG angehängt ist, antwortet der Server nicht mehr und kann das NAT-Gateway oder die Datenbank nicht erreichen.
- Ursache: NSGs verweigern allen Verkehr, der von keiner Regel erlaubt wird, in beiden Richtungen.
- Lösung: Fügen Sie explizite
EGRESS-Regeln für den ausgehenden Verkehr hinzu, den der Server benötigt, sowieINGRESS-Regeln für jede Client-Adresse und jeden Port.
-
Erwartung, dass die NSG den Load Balancer schützt
- Problem: Sie hängen in einem Design-Dokument eine NSG an den ALB, aber der Terraform-Plan bietet keinen Platz dafür.
- Ursache: Mitglieder einer NSG sind NICs und VMs. Der Listener des Load Balancers ist kein Mitglied.
- Lösung: Filtern Sie auf den Ziel-NICs mit Regeln, die nur die feste
lb_private_ips-Adresse des Load Balancers zulassen (Abschnitt 4.1).
-
Health Checks markieren jedes Ziel als gestört
- Problem: Der ALB meldet Fehler, obwohl der API-Server läuft.
- Ursache: Der HTTP-Health-Check fordert einen Pfad an, den die Anwendung nicht bereitstellt, oder die NSG blockiert den Health-Check von der privaten Adresse des ALB.
- Lösung: Richten Sie
http_health_check.pathauf einen Endpunkt ein, der den konfiguriertenresponsezurückgibt, und erlauben Sie die private IP des ALB auf dem Dienstport.
Zusammenfassung
Sie können die API von TaskBoard nun hinter einem Load Balancer positionieren und sie als Code absichern. NSGs enthalten zustandsbehaftete Regeln mit Standardablehnung, die Sie Servern oder NICs zuweisen. Der ALB verbindet ein öffentliches Listener-LAN mit einem privaten Ziel-LAN, leitet HTTP-Anfragen nach Pfad an Zielgruppen mit Health Checks weiter und kann fest definierte Antworten zurückgeben. Der NLB deckt ausschließlich TCP-basiertes Balancing ab, und die Sicherheitsgrenze befindet sich stets an den Ziel-NICs.
Wichtige Punkte:
- NSG-Regeln erlauben nur den Datenverkehr; alles andere wird in beide Richtungen blockiert, und Antworten werden zugelassen (zustandsbehaftet)
- NSG-Mitglieder sind NICs und VMs; verwenden Sie NSGs nicht parallel mit der NIC-basierten Firewall
- Ein ALB benötigt einen Listener, eine Weiterleitungsregel und eine Zielgruppe; öffentliche Listener benötigen reservierte IPs
- Verwenden Sie den ALB für HTTP-Routing und TLS-Terminierung, den NLB für Layer-4-TCP-Balancing
- Keiner der Load Balancer unterstützt SNAT; Ziele nutzen das NAT-Gateway für ausgehenden Datenverkehr
Wichtige Begriffe:
- Network Security Group (NSG): Ein Satz zustandsbehafteter Erlaubnisregeln, die auf die NICs oder VMs der Mitglieder in einem VDC angewendet werden
- Listener-LAN: Das LAN, in dem ein Load Balancer Client-Verbindungen annimmt
- Ziel-LAN: Das private LAN, in dem ein Load Balancer seine Ziele über
lb_private_ipserreicht - Zielgruppe: Eine wiederverwendbare Gruppe von ALB-Zielen mit einem Algorithmus und Health Checks
- Weiterleitungsregel: Die Listener-Konfiguration, die eine IP und einen Port auf Ziele abbildet, mit HTTP-Regeln auf einem ALB
Nächste Schritte
Weiter lernen: Einheit 2.4: Storage-Provisionierung als Code
Verwandte Themen: