NLB erstellen

STACKIT Network Load Balancer (NLBs) können über das STACKIT Portal, die STACKIT API oder den STACKIT Terraform Provider erstellt werden.

Vorbereitung

Bevor Sie einen NLB erstellen, sollten Sie einige Überlegungen anstellen. Nutzen Sie die folgende Liste, um die benötigten Informationen zu sammeln und Entscheidungen zu treffen, bevor Sie beginnen:

• Benennung: Wählen Sie einen DNS-konformen Namen (Kleinbuchstaben, Bindestriche, Zahlen).
• Sichtbarkeit: Entscheiden Sie, ob der NLB öffentlich oder privat sein soll. Für öffentlichen Zugriff legen Sie fest, ob Sie eine bestehende Public IP anhängen oder STACKIT automatisch eine zuweisen lassen möchten. Für privaten Zugriff wird automatisch eine private IP zugewiesen.
• Performance: Schätzen Sie die erwartete Anzahl an Verbindungen zu den Diensten/Servern hinter dem Load Balancer, um einen geeigneten Serviceplan auswählen zu können.
• Netzwerk: Bestimmen Sie das STACKIT Network, in dem der NLB betrieben wird. Alle Targets müssen sich im selben Netzwerk wie der Load Balancer befinden.
• Sicherheit: Wenn Sie Admin- oder sensible Ports öffentlich freigeben, planen Sie ACL-Regeln (d. h. erlaubte Quell-IP-Bereiche).
• Ports und Protokolle (Listener): Listen Sie die externen Ports auf, die Sie freigeben möchten, und das jeweilige Protokoll (TCP oder UDP). Optional können Sie einen beschreibenden Listener-Namen pro Port/Protokoll definieren.
• Target Pools und Targets: Definieren Sie für jeden Listener einen Target Pool mit einem Zielport und den Backend-Targets, die den Datenverkehr empfangen sollen. Erfassen Sie die IP-Adresse jedes Targets (und optional einen Anzeigenamen). Stellen Sie sicher, dass sich jedes Target im selben Netzwerk wie der NLB befindet.
• Session Persistence: Entscheiden Sie, ob mehrere Anfragen einer Benutzersitzung dasselbe Target erreichen müssen. Falls ja, aktivieren Sie Session Persistence (basierend auf der Quell-IP). Das Aktivieren der Persistenz ändert den Load-Balancing-Algorithmus von Round Robin zu Maglev.
• Health Checks: Entscheiden Sie, ob Sie sinnvolle Standardwerte beibehalten oder anpassen möchten. Typische Standardwerte sind: Down nach 3 Prüfungen, Prüfintervall 5 Sekunden, Up nach 1 Prüfung. Bei Anpassung legen Sie das gewünschte Intervall und die Up/Down-Schwellenwerte fest.

Optional können Sie sich einen Überblick über die anfallenden Kosten verschaffen, indem Sie den STACKIT Pricing Calculator nutzen, um die Kosten basierend auf Ihrer geplanten NLB-Konfiguration zu schätzen. Bei Nutzung des Portals werden die Kosten während des Erstellungsprozesses dynamisch in der Benutzeroberfläche berechnet und angezeigt.

Ablauf

Folgen Sie den nachstehenden Schritten, um einen NLB mit Ihrer bevorzugten Methode zu erstellen.

Um die folgenden Beispiele erfolgreich auszuführen:

• Es muss ein Netzwerk vorhanden sein.
• Es muss ein Target (Server) vorhanden sein.

Standardmäßig wird ein neu erstellter NLB mit dem Serviceplan der Stufe p10 bereitgestellt. Wenn Sie einen anderen Plan benötigen, müssen Sie diesen explizit angeben.

Über das Portal

Besuchen Sie das STACKIT Portal, wählen Sie Ihr gewünschtes Projekt aus und folgen Sie diesen Schritten:

1. Klicken Sie in der Seitenleiste unter Networking auf Network Load Balancer.
2. Klicken Sie auf die Schaltfläche Create Network Load Balancer.
3. Füllen Sie die erforderlichen Felder mit den zuvor vorbereiteten Informationen aus.
4. Klicken Sie auf die Schaltfläche Order fee-based, um den NLB zu erstellen.

Fertig! Ihr STACKIT Network Load Balancer wird erstellt und ist in Kürze einsatzbereit.

Als Ergebnis erscheinen zwei neue Instanzen unter Computing > Server, wie unten dargestellt. Diese Instanzen repräsentieren die Load-Balancer-Knoten, die den eingehenden Datenverkehr verarbeiten und an Ihre definierten Targets verteilen:

Unter Networking > Security Groups finden Sie möglicherweise auch neu erstellte Sicherheitsgruppen, die Ihrem NLB zugeordnet sind. Dies ist nicht der Fall, wenn Sie die Zuweisung der Target-Sicherheitsgruppe bei der NLB-Erstellung deaktiviert haben:

Über die API

Voraussetzungen

Um einen STACKIT Network Load Balancer über die API zu erstellen, müssen Sie ein temporäres Bearer-Token zur Authentifizierung unter einem Service-Konto erwerben.

• Lesen Sie „Dienste mit einem Service-Konto nutzen”, um zu erfahren, wie Sie ein Service-Konto erstellen und ein Bearer-Token generieren.
• Lesen Sie den STACKIT CLI Authentication Guide, um mehr über mögliche CLI- und Umgebungskonfigurationen zu erfahren, mit denen Sie Bearer-Tokens erhalten können.
• Bitte beachten Sie die STACKIT Network Load Balancer API-Dokumentation, um mehr über die verfügbaren API-Endpunkte, Parameter und die Struktur der Request-/Response-Bodies zu erfahren.

Um die Funktionalität dieser Anfrage mit echten Daten zu validieren, können Sie UI-basierte API-Clients wie Postman oder Thunder Client oder Kommandozeilen-Tools wie cURL verwenden.

Direkte API-Anfragen sind zwar nützlich zum Testen oder zur programmatischen Erstellung von Ressourcen über imperative Skripte (z. B. Python oder Go), für die Verwaltung von Produktionsinfrastruktur wird jedoch dringend empfohlen, den STACKIT Terraform Provider zu verwenden. Terraform ermöglicht die deklarative Ressourcendefinition (Infrastructure as Code) und übernimmt die zugrunde liegenden API-Interaktionen – wie die unten beschriebene – automatisch im Hintergrund.

Die folgende Anfrage stellt nur ein minimales NLB-Setup bereit und berücksichtigt nicht die Notwendigkeit eines bereits vorhandenen Netzwerks oder Zielservers. Ohne eine gültige networkId sowie gültige displayName und ip für die Targets wird die Anfrage fehlschlagen.

Anfragedetails

Methode: POST

Endpunkt-URL:

https://load-balancer.api.stackit.cloud/v2/projects/{projectId}/regions/{region}/load-balancers

Header:

• Content-Type: application/json
• Authorization: Bearer <Ihr_Bearer_Token>

Request-Body:

{
  "name": "my-load-balancer-01",
  "networks": [
    {
      "networkId": "2028e5d4-af4f-45e2-98df-502be37a4317 <UUID des Netzwerks, in dem sich Load Balancer und Targets befinden>",
      "role": "ROLE_LISTENERS_AND_TARGETS"
    }
  ],
  "targetPools": [
    {
      "name": "web-backend-pool",
      "targetPort": 8080,
      "targets": [
        {
          "displayName": "web-server-01",
          "ip": "10.1.2.5 <Interne IPv4-Adresse des ersten Zielservers>"
        },
        {
          "displayName": "web-server-02",
          "ip": "10.1.2.6 <Interne IPv4-Adresse eines zweiten Zielservers>"
        }
      ],
      "activeHealthCheck": {
        "healthyThreshold": 2,
        "interval": "3s",
        "intervalJitter": "3s",
        "timeout": "3s",
        "unhealthyThreshold": 2
      }
    }
  ],
  "listeners": [
    {
      "displayName": "http-listener",
      "port": 80,
      "protocol": "PROTOCOL_TCP",
      "targetPool": "web-backend-pool <Muss mit einem in 'targetPools' definierten 'name' übereinstimmen>"
    }
  ],
  "options": {
    "privateNetworkOnly": true,
    "accessControl": {
      "allowedSourceRanges": [
        "0.0.0.0/0 <CIDR-Bereich, der auf diesen Load Balancer zugreifen darf>"
      ]
    }
  }
}

Über Terraform

Die folgenden Beispiele zeigen, wie Sie einen NLB mit dem offiziellen STACKIT Terraform Provider und der stackit_loadbalancer-Ressource erstellen. Das erste Beispiel zeigt eine minimale Definition ohne Netzwerk und Zielserver, während das zweite Beispiel die Erstellung eines Netzwerks und Servers als Voraussetzungen für den Load Balancer beinhaltet.

Diese Definitionen wurden getestet und funktionieren nachweislich mit dem STACKIT Terraform Provider Version 0.79.0. Wenn Sie eine andere Version verwenden, beachten Sie bitte die offizielle Dokumentation für mögliche Änderungen bei Ressourcendefinitionen oder erforderlichen Parametern.

Minimale Definition

terraform {
  required_providers {
    stackit = {
      source = "stackitcloud/stackit"
    }
  }
}

# Key-Flow (mit Pfad)
provider "stackit" {
  # Anmeldedaten-Konfiguration erfolgt üblicherweise hier oder in Umgebungsvariablen
  default_region           = "eu01"
  service_account_key_path = pathexpand("~/.stackit/credentials.json")
}

resource "stackit_loadbalancer" "example" {
  project_id = "<Ihre-Projekt-UUID>"
  name       = "example-tf-load-balancer"

  networks = [
    {
      network_id = "<Ihre-Netzwerk-UUID>"
      role       = "ROLE_LISTENERS_AND_TARGETS"
    }
  ]
  options = {
    private_network_only = true
  }

  target_pools = [
    {
      name        = "example-pool"
      target_port = 80
      targets = [
        {
          display_name = "<Name-Ihres-Zielservers>"
          ip           = "<IPv4-Ihres-Zielservers>"
        }
      ]
    }
  ]

  listeners = [
    {
      display_name = "example-listener"
      port         = 80
      protocol     = "PROTOCOL_TCP"
      target_pool  = "example-pool"
    }
  ]
}

Setup inklusive Netzwerk und Server

terraform {
  required_providers {
    stackit = {
      source = "stackitcloud/stackit"
    }
  }
}

# Key-Flow (mit Pfad)
provider "stackit" {
  # Anmeldedaten-Konfiguration erfolgt üblicherweise hier oder in Umgebungsvariablen
  default_region           = "eu01"
  service_account_key_path = pathexpand("~/.stackit/credentials.json")
}

locals {
  project_id = "<Ihre-Projekt-UUID>" # Zum Beispiel: 0aa82d91-66b9-4cd7-ac10-e7973faa8760
}

# Voraussetzung: Netzwerk
resource "stackit_network" "example_network" {
  project_id = local.project_id
  name       = "example_network"
  routed     = true
  # Standard ist /25
  ipv4_nameservers = ["1.1.1.1", "8.8.8.8", "9.9.9.9"]
}

resource "stackit_network_interface" "example_interface" {
  network_id = stackit_network.example_network.network_id
  project_id = local.project_id
}

# Voraussetzung: Server
resource "stackit_server" "example" {
  project_id = local.project_id
  name       = "example-tf-server"
  boot_volume = {
    size        = 20
    source_type = "image"
    # Ubuntu 24.04 2025-11-24
    source_id = "596b7af6-86a8-4a6e-ab9f-259affceac95"
  }
  # Maschinentypen ohne CPU-Überprovisioning AMD Gen1
  machine_type = "c1a.1d"

  network_interfaces = [
    stackit_network_interface.example_interface.network_interface_id
  ]
}

# Load Balancer erstellen
resource "stackit_loadbalancer" "example" {
  project_id = local.project_id
  name       = "example-tf-load-balancer"

  networks = [
    {
      network_id = stackit_network.example_network.network_id
      role       = "ROLE_LISTENERS_AND_TARGETS"
    }
  ]
  options = {
    private_network_only = true
  }

  target_pools = [
    {
      name        = "example-pool"
      target_port = 80
      targets = [
        {
          display_name = stackit_server.example.name
          ip           = stackit_network_interface.example_interface.ipv4
        }
      ]
    }
  ]

  listeners = [
    {
      display_name = "example-listener"
      port         = 80
      protocol     = "PROTOCOL_TCP"
      target_pool  = "example-pool"
    }
  ]
}