Einen ALB erstellen

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

Vorbereitung

Bevor Sie einen ALB erstellen, sollten Sie einige Punkte beachten. Nutzen Sie die folgende Liste, um Entscheidungen zu treffen und alle benötigten Informationen vorab zu sammeln:

• Benennung: Wählen Sie einen DNS-konformen Namen (Kleinbuchstaben, Bindestriche, Zahlen).
• Sichtbarkeit: Entscheiden Sie, ob der ALB öffentlich oder privat sein soll. Für öffentlichen Zugriff legen Sie fest, ob Sie eine vorhandene Public IP zuweisen oder automatisch durch STACKIT zuweisen lassen. Für privaten Zugriff wird automatisch eine private IP zugewiesen.
• Netzwerk: Legen Sie das STACKIT-Netzwerk fest, in dem der ALB betrieben wird. Alle Targets müssen sich im selben Netzwerk wie der Load Balancer befinden.
• Target-Pools und Targets: Definieren Sie pro Listener einen Target-Pool mit Target-Port sowie die Backend-Targets, die den Traffic erhalten. Erfassen Sie für jedes Target die IP-Adresse (optional auch den Anzeigenamen). Stellen Sie sicher, dass sich jedes Target im selben Netzwerk wie der ALB befindet.
• Health Checks: Wählen Sie TCP oder HTTP. Bei TCP prüft der ALB die Erreichbarkeit am Target-Port. Bei HTTP konfigurieren Sie den Prüfpfad (z. B. /health) sowie die Liste zulässiger Statuscodes (z. B. 200). Standardwerte: Intervall 5 Sekunden, als nicht verfügbar nach 3 fehlgeschlagenen Prüfungen, als verfügbar nach 1 erfolgreicher Prüfung. Passen Sie Schwellwerte und Intervall bei Bedarf an.
• Ports, Hosts und Regeln (Listener): Geben Sie für jeden Listener den externen Port, einen Hostnamen (z. B. stackit.cloud oder *.stackit.cloud) und Regeln an, die auf einen Target-Pool weiterleiten. Jede Regel muss einen Pfadtyp (Exact oder Prefix) sowie einen Pfad (z. B. /foo) definieren.
• Erweiterte Listener-Einstellungen:
  • WebSocket: Aktivieren Sie diese Option nur, wenn Ihre Anwendung WebSocket benötigt. Prüfen Sie, ob das Backend HTTP Upgrade und langlebige Verbindungen unterstützt.
  • HTTP-Header: Wählen Sie Header-Namen und exakte Werte, die von Ihrer Anwendung oder Ihrem Gateway zuverlässig gesetzt werden (z. B. User-Agent: Mozilla/5.0). Vermeiden Sie nutzerkontrollierte Header.
  • Cookie-Persistenz: Verwenden Sie diese Option, wenn Session-Affinität erforderlich ist. Wählen Sie einen Cookie-Namen und eine TTL (in Sekunden). Stellen Sie sicher, dass Clients das Cookie akzeptieren.
  • Query-Parameter: Routen Sie nur über Parameter, die konsistent vorhanden sind. Definieren Sie Namen und exakten Wert für den Abgleich (z. B. name=admin).
• Sicherheitskonzept: Wenn Sie Admin- oder sensible Ports öffentlich bereitstellen, planen Sie ACL-Regeln (zulässige Quell-IP-Bereiche).

Optional können Sie sich mit dem STACKIT Pricing Calculator einen Überblick über die zu erwartenden Kosten Ihrer geplanten ALB-Konfiguration verschaffen. Wenn Sie das Portal verwenden, werden die Kosten während des Erstellungsprozesses dynamisch in der UI berechnet und angezeigt.

Ablauf

Folgen Sie den untenstehenden Schritten, um einen ALB mit Ihrer bevorzugten Methode zu erstellen.

Damit Sie die folgenden Beispiele erfolgreich ausführen können:

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

Über das Portal

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

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

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

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

Möglicherweise finden Sie unter Networking > Security Groups auch neu angelegte Security Groups, die Ihrem ALB zugeordnet sind. Dies gilt nicht, wenn Sie die Zuweisung der Target-Security-Group während der ALB-Erstellung deaktiviert haben:

Über die API

Voraussetzungen

Um einen STACKIT Application Load Balancer über die API zu erstellen, benötigen Sie zur Authentifizierung ein temporäres Bearer-Token für ein Servicekonto.

• Lesen Sie Access services with a service account, um zu erfahren, wie Sie ein Servicekonto erstellen und ein Bearer-Token generieren.
• Lesen Sie den STACKIT CLI Authentication Guide, um mehr über mögliche CLI- und Umgebungs-Setups zum Abruf von Bearer-Tokens zu erfahren.
• In der STACKIT Application Load Balancer API-Dokumentation finden Sie weitere Informationen zu verfügbaren Endpunkten, Parametern sowie zur Struktur von Request- und Response-Bodies.

Um diese Anfragefunktion mit echten Daten zu validieren, können Sie UI-basierte API-Clients wie Postman oder Thunder Client sowie Kommandozeilen-Tools wie cURL verwenden.

Direkte API-Anfragen sind hilfreich für Tests oder die programmgesteuerte Erstellung von Ressourcen über imperative Skripte (z. B. in Python oder Go). Für den Betrieb von Produktivinfrastruktur wird jedoch die Verwendung des STACKIT Terraform Providers ausdrücklich empfohlen. Terraform ermöglicht deklarative Ressourcendefinitionen (Infrastructure as Code) und übernimmt API-Interaktionen wie die unten gezeigte automatisch im Hintergrund.

Request-Details

Method: POST

Endpoint URL:

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

Headers:

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

Request body:

{
  "name": "demo-alb",
  "externalAddress": "45.xxx.xxx.xxx",
  "options": {
    "ephemeralAddress": false,
    "privateNetworkOnly": false
  },
  "networks": [
    {
      "networkId": "a8815d0c-874b-4e47-xxxx-xxxxxxxxxxx",
      "role": "ROLE_LISTENERS_AND_TARGETS"
    }
  ],
  "disableTargetSecurityGroupAssignment": false,
  "planID": "p10",
  "listeners": [
    {
      "port": 80,
      "protocol": "PROTOCOL_HTTP",
      "http": {
        "hosts": [
          {
            "host": "app.stackit.cloud",
            "rules": [
              {
                "pathPrefix": "/",
                "targetPool": "demo-alb-tp-80"
              }
            ]
          }
        ]
      }
    }
  ],
  "targetPools": [
    {
      "name": "demo-alb-tp-80",
      "targetPort": 80,
      "targets": [
        {
          "displayName": "webserver01",
          "ip": "10.xxx.xxx.xxx"
        },
        {
          "displayName": "webserver02",
          "ip": "10.xxx.xxx.xxx"
        }
      ]
    }
  ]
}

Die oben gezeigte Datenstruktur stellt eine minimale ALB-Konfiguration dar. Für erweiterte Konfigurationen, die auf diesem minimalen Setup aufbauen, siehe Erweiterte API-Templates.

Über Terraform

Ein funktionierendes und aktuelles Beispiel zur Verwendung der neuesten Version der Ressource stackit_application_load_balancer finden Sie in der Dokumentation des STACKIT Terraform Providers.

Zur Veranschaulichung der grundlegenden Struktur der ALB-Ressource finden Sie unten ein eigenständiges Konfigurationsbeispiel.

Bitte beachten Sie, dass diesem Beispiel notwendige Abhängigkeiten wie ein Netzwerk und ein Target-Server fehlen und es daher nicht unverändert angewendet werden kann. Es zeigt das Format der ALB-Ressourcendefinition für STACKIT Terraform Provider v0.85.0.

resource "stackit_application_load_balancer" "example-alb" {
  project_id = "<your-project-uuid>"
  region     = "eu01"
  name       = "example-load-balancer"
  plan_id    = "p10"
  listeners = [{
    name = "my-listener"
    port = 443
    http = {
      hosts = [{
        host = "*"
        rules = [{
          target_pool = "my-target-pool"
          web_socket  = true
          query_parameters = [{
            name        = "my-query-key"
            exact_match = "my-query-value"
          }]
          headers = [{
            name        = "my-header-key"
            exact_match = "my-header-value"
          }]
          path = {
            prefix = "/path"
          }
          cookie_persistence = {
            name = "my-cookie"
            ttl  = "60s"
          }
        }]
      }]
    }
    https = {
      certificate_config = {
        certificate_ids = [
          "<your-1st-certificate-id>",
          "<your-2nd-certificate-id>",
        ]
      }
    }
    protocol        = "PROTOCOL_HTTPS"
    waf_config_name = "my-waf-config"
    }
  ]
  networks = [
    {
      network_id = "<your-network-uuid>"
      role       = "ROLE_LISTENERS_AND_TARGETS"
    }
  ]
  options = {
    acl                  = ["123.123.123.123/24", "12.12.12.12/24"]
    ephemeral_address    = true
    private_network_only = false
  }
  target_pools = [
    {
      name = "my-target-pool"
      active_health_check = {
        interval            = "0.500s"
        interval_jitter     = "0.010s"
        timeout             = "1s"
        healthy_threshold   = "5"
        unhealthy_threshold = "3"
        http_health_checks = {
          ok_status = ["200", "201"]
          path      = "/healthy"
        }
      }
      target_port = 80
      targets = [
        {
          display_name = "my-target"
          ip           = "<your-target-server-ipv4>"
        }
      ]
      tls_config = {
        enabled                     = true
        skip_certificate_validation = false
        custom_ca                   = chomp(file("path/to/PEM_formated_CA"))
      }
    }
  ]
}