13 Min. Lesezeit

Lernziele

Am Ende dieses Moduls werden Sie in der Lage sein:

  • Network Security Groups und deren Regeln mit `ionoscloud_nsg` und `ionoscloud_nsg_firewallrule` zu definieren und sie an Server-NICs anzubinden
  • Einen Managed Application Load Balancer mit `ionoscloud_application_loadbalancer`, einer Weiterleitungsregel und einer Zielgruppe bereitzustellen
  • Pfadbasierte HTTP-Routing-Regeln und Health Checks für die API von TaskBoard in Code zu konfigurieren
  • Einen Managed Network Load Balancer mit `ionoscloud_networkloadbalancer` bereitzustellen und zwischen NLB und ALB zu wählen
  • Lastverteilte Server mit NIC-Ebenen-Regeln zu schützen, die nur die private Adresse des Load Balancers zulassen

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:

  1. Weisen Sie dem ALB eine feste lb_private_ips-Adresse zu, beispielsweise 10.10.1.6.
  2. Erlauben Sie den Dienstport auf der Ziel-NIC nur von dieser Adresse (Abschnitt 1).
  3. 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_TOKEN festgelegt
  • 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 AVAILABLE mit 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 plan zeigt 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:

  1. 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, sowie INGRESS-Regeln für jede Client-Adresse und jeden Port.
  2. 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).
  3. 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.path auf einen Endpunkt ein, der den konfigurierten response zurü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_ips erreicht
  • 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: