Regionenübergreifenden internen Application Load Balancer mit Back-Ends von VM-Instanzgruppen einrichten

Dieses Dokument enthält Anleitungen zum Konfigurieren eines regionenübergreifenden internen Application Load Balancer für Ihre Dienste, die auf Compute Engine-VM-Instanzen ausgeführt werden.

Hinweise

Bevor Sie diese Anleitung durcharbeiten, sollten Sie sich mit Folgendem vertraut machen:

SSL-Zertifikatsressource einrichten

Erstellen Sie eine Zertifikatmanager-SSL-Zertifikatsressource, wie im Folgenden beschrieben:

Wir empfehlen die Verwendung eines von Google verwalteten Zertifikats.

Berechtigungen

Damit Sie dieser Anleitung folgen können, müssen Sie in der Lage sein, Instanzen zu erstellen und ein Netzwerk in einem Projekt zu ändern. Sie müssen entweder Inhaber oder Bearbeiter des Projekts sein oder alle folgenden Compute Engine-IAM-Rollen haben.

Aufgabe Erforderliche Rolle
Netzwerke, Subnetze und Load-Balancer-Komponenten erstellen Compute-Netzwerkadministrator
Firewallregeln hinzufügen und löschen Compute-Sicherheitsadministrator
Instanzen erstellen Compute-Instanzadministrator

Weitere Informationen finden Sie in folgenden Leitfäden:

Einrichtung: Übersicht

Sie können den Load Balancer wie im folgenden Diagramm dargestellt konfigurieren:

Bereitstellung mit Hochverfügbarkeit für regionenübergreifenden internen Application Load Balancer
Bereitstellung mit Hochverfügbarkeit für regionenübergreifenden internen Application Load Balancer (zum Vergrößern klicken).

Wie im Diagramm dargestellt, wird in diesem Beispiel ein regionenübergreifender interner Application Load Balancer in einem VPC-Netzwerk mit einem Backend-Dienst und zwei verwalteten Backend-Instanzgruppen in der Region REGION_A und REGION_B erstellt.

Das Diagramm zeigt Folgendes:

  1. Ein VPC-Netzwerk mit den folgenden Subnetzen:

    • Subnetz SUBNET_A und ein Nur-Proxy-Subnetz in REGION_A.
    • Subnetz SUBNET_B und ein Nur-Proxy-Subnetz in REGION_B.

    Sie müssen in jeder Region eines VPC-Netzwerks, in dem Sie regionenübergreifende interne Application Load Balancer verwenden, Nur-Proxy-Subnetze erstellen. Das Nur-Proxy-Subnetz der Region wird von allen regionenübergreifenden internen Application Load Balancern in der Region gemeinsam genutzt. Quelladressen von Paketen, die der Load-Balancer an die Back-Ends Ihres Dienstes sendet, werden vom Nur-Proxy-Subnetz zugewiesen. In diesem Beispiel hat das Nur-Proxy-Subnetz für die Region REGION_A den primären IP-Adressbereich 10.129.0.0/23 und für REGION_B den primären IP-Adressbereich 10.130.0.0/23. Dies ist die empfohlene Subnetzgröße.

  2. Bei der Einrichtung für Hochverfügbarkeit werden verwaltete Instanzgruppen-Backends für Compute Engine-VM-Bereitstellungen in den Regionen REGION_A und REGION_B verwendet. Wenn Back-Ends in einer Region ausfallen, wird der Traffic auf die andere Region umgeleitet.

  3. Ein globaler Backend-Dienst, der die Nutzung und die Integrität von Backends überwacht.

  4. Eine globale URL-Zuordnung, die die URL einer Anfrage parst und Anfragen anhand des Hosts und Pfades der Anfrage-URL an bestimmte Backend-Dienste weiterleitet.

  5. Ein globaler HTTP- oder HTTPS-Zielproxy, der eine Anfrage vom Nutzer empfängt und an die URL-Zuordnung weiterleitet. Konfigurieren Sie für HTTPS eine globale SSL-Zertifikatsressource. Der Zielproxy verwendet das SSL-Zertifikat, um SSL-Traffic zu entschlüsseln, wenn Sie das HTTPS-Load-Balancing konfigurieren. Der Zielproxy kann Traffic über HTTP oder HTTPS an Ihre Instanzen weiterleiten.

  6. Globale Weiterleitungsregeln, die über die regionale interne IP-Adresse Ihres Load-Balancers verfügen, um jede eingehende Anfrage an den Zielproxy weiterzuleiten.

    Die mit der Weiterleitungsregel verknüpfte interne IP-Adresse kann aus einem Subnetz im selben Netzwerk und in derselben Region wie die Back-Ends stammen. Beachten Sie folgende Bedingungen:

    • Die IP-Adresse kann (nicht erforderlich) aus demselben Subnetz wie die Backend-Instanzgruppen stammen.
    • Die IP-Adresse darf nicht aus dem reservierten Nur-Proxy-Subnetz stammen, dessen Flag --purpose auf GLOBAL_MANAGED_PROXY gesetzt ist.
    • Wenn Sie dieselbe interne IP-Adresse mit mehreren Weiterleitungsregeln verwenden möchten, setzen Sie das Flag --purpose für die IP-Adresse auf SHARED_LOADBALANCER_VIP.

  7. Optional: Konfigurieren Sie DNS-Routingrichtlinien vom Typ GEO, um Clienttraffic an die Load-Balancer-VIP in der Region weiterzuleiten, die dem Client am nächsten ist.

Netzwerk und Subnetze konfigurieren

Konfigurieren Sie im VPC-Netzwerk ein Subnetz in jeder Region, in der Ihre Back-Ends konfiguriert sind. Konfigurieren Sie außerdem eine proxy-only-subnet in jeder Region, in der Sie den Load Balancer konfigurieren möchten.

In diesem Beispiel werden das folgende VPC-Netzwerk, die folgende Region und die folgenden Subnetze verwendet:

  • Netzwerk. Das Netzwerk ist ein VPC-Netzwerk im benutzerdefinierten Modus mit dem Namen NETWORK.

  • Subnetze für Backends

    • Ein Subnetz mit dem Namen SUBNET_A in der Region REGION_A verwendet 10.1.2.0/24 für seinen primären IP-Bereich.
    • Ein Subnetz mit dem Namen SUBNET_B in der Region REGION_B verwendet 10.1.3.0/24 für seinen primären IP-Bereich.

  • Subnetze für Proxys.

    • Ein Subnetz mit dem Namen PROXY_SN_A in der Region REGION_A verwendet 10.129.0.0/23 für seinen primären IP-Bereich.
    • Ein Subnetz mit dem Namen PROXY_SN_B in der Region REGION_B verwendet 10.130.0.0/23 für seinen primären IP-Bereich.

Auf mehrere regionenübergreifende interne Application Load Balancer kann von jeder Region innerhalb der VPC aus zugegriffen werden. Daher können Clients aus jeder Region global auf Ihre Load-Balancer-Back-Ends zugreifen.

Backend-Subnetze konfigurieren

Console

  1. Rufen Sie in der Google Cloud Console die Seite VPC-Netzwerke auf.

    Zur Seite VPC-Netzwerke

  2. Klicken Sie auf VPC-Netzwerk erstellen.

  3. Geben Sie einen Namen für das Netzwerk an.

  4. Wählen Sie im Abschnitt Subnetze als Modus für die Subnetzerstellung Benutzerdefiniert aus.

  5. Erstellen Sie ein Subnetz für die Back-Ends des Load-Balancers. Geben Sie im Bereich Neues Subnetz folgende Informationen ein:

    • Geben Sie einen Namen für das Subnetz an.
    • Wählen Sie eine Region aus: REGION_A
    • Geben Sie einen IP-Adressbereich ein: 10.1.2.0/24

  6. Klicken Sie auf Fertig.

  7. Klicken Sie auf Subnetz hinzufügen.

  8. Erstellen Sie ein Subnetz für die Back-Ends des Load-Balancers. Geben Sie im Bereich Neues Subnetz folgende Informationen ein:

    • Geben Sie einen Namen für das Subnetz an.
    • Wählen Sie eine Region aus: REGION_B
    • Geben Sie einen IP-Adressbereich ein: 10.1.3.0/24

  9. Klicken Sie auf Fertig.

  10. Klicken Sie auf Erstellen.

gcloud

  1. Erstellen Sie mit dem Befehl gcloud compute networks create das benutzerdefinierte VPC-Netzwerk:

    gcloud compute networks create NETWORK \
    --subnet-mode=custom

  2. Erstellen Sie mit dem Befehl gcloud compute networks subnets create ein Subnetz im Netzwerk NETWORK in der Region REGION_A:

    gcloud compute networks subnets create SUBNET_A \
    --network=NETWORK \
    --range=10.1.2.0/24 \
    --region=REGION_A

  3. Erstellen Sie mit dem Befehl gcloud compute networks subnets create ein Subnetz im Netzwerk NETWORK in der Region REGION_B:

    gcloud compute networks subnets create SUBNET_B \
    --network=NETWORK \
    --range=10.1.3.0/24 \
    --region=REGION_B

Terraform

Verwenden Sie zum Erstellen des VPC-Netzwerks die Ressource google_compute_network.

resource "google_compute_network" "default" {
  auto_create_subnetworks = false
  name                    = "lb-network-crs-reg"
  provider                = google-beta
}

Verwenden Sie zum Erstellen des VPC-Subnetzes im Netzwerk lb-network-crs-reg die Ressource google_compute_subnetwork.

resource "google_compute_subnetwork" "subnet_a" {
  provider      = google-beta
  ip_cidr_range = "10.1.2.0/24"
  name          = "lbsubnet-uswest1"
  network       = google_compute_network.default.id
  region        = "us-west1"
}
 
resource "google_compute_subnetwork" "subnet_b" {
  provider      = google-beta
  ip_cidr_range = "10.1.3.0/24"
  name          = "lbsubnet-useast1"
  network       = google_compute_network.default.id
  region        = "us-east1"
}

API

Stellen Sie eine POST-Anfrage an die Methode networks.insert. Ersetzen Sie dabei PROJECT_ID durch Ihre Projekt-ID.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks

{
 "routingConfig": {
   "routingMode": "regional"
 },
 "name": "NETWORK",
 "autoCreateSubnetworks": false
}

Stellen Sie eine POST-Anfrage an die Methode subnetworks.insert. Ersetzen Sie dabei PROJECT_ID durch Ihre Projekt-ID.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_A/subnetworks

{
 "name": "SUBNET_A",
 "network": "projects/PROJECT_ID/global/networks/lb-network-crs-reg",
 "ipCidrRange": "10.1.2.0/24",
 "region": "projects/PROJECT_ID/regions/REGION_A",
}

Stellen Sie eine POST-Anfrage an die Methode subnetworks.insert. Ersetzen Sie dabei PROJECT_ID durch Ihre Projekt-ID.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_B/subnetworks

{
 "name": "SUBNET_B",
 "network": "projects/PROJECT_ID/global/networks/NETWORK",
 "ipCidrRange": "10.1.3.0/24",
 "region": "projects/PROJECT_ID/regions/REGION_B",
}

Nur-Proxy-Subnetz konfigurieren

Ein Nur-Proxy-Subnetz stellt eine Reihe von IP-Adressen bereit, die Google Cloud zum Ausführen von Envoy-Proxys in Ihrem Namen verwendet. Die Proxys beenden Verbindungen vom Client und erstellen neue Verbindungen zu den Back-Ends.

Dieses Nur-Proxy-Subnetz wird von allen Envoy-basierten regionalen Load-Balancern in derselben Region des VPC-Netzwerks verwendet. Pro Zweck, Region und Netzwerk kann jeweils nur ein Nur-Proxy-Subnetz aktiv sein.

Console

Wenn Sie die Google Cloud Console verwenden, können Sie das Nur-Proxy-Subnetz später auf der Seite Load Balancing erstellen.

Führen Sie die folgenden Schritte aus, wenn Sie jetzt das Nur-Proxy-Subnetz erstellen möchten:

  1. Rufen Sie in der Google Cloud Console die Seite VPC-Netzwerke auf.

    Zur Seite VPC-Netzwerke

  2. Klicken Sie auf den Namen des VPC-Netzwerks.
  3. Klicken Sie auf dem Tab Subnetz auf Subnetz hinzufügen.
  4. Geben Sie einen Namen für das Nur-Proxy-Subnetz an.
  5. Wählen Sie eine Region aus: REGION_A
  6. Wählen Sie in der Liste Zweck die Option Regionenübergreifender verwalteter Proxy aus.
  7. Geben Sie im Feld IP-Adressbereich den Wert 10.129.0.0/23 ein.
  8. Klicken Sie auf Hinzufügen.

Erstellen Sie das Nur-Proxy-Subnetz in REGION_B.

  1. Klicken Sie auf dem Tab Subnetz auf Subnetz hinzufügen.
  2. Geben Sie einen Namen für das Nur-Proxy-Subnetz an.
  3. Wählen Sie eine Region aus: REGION_B
  4. Wählen Sie in der Liste Zweck die Option Regionenübergreifender verwalteter Proxy aus.
  5. Geben Sie im Feld IP-Adressbereich den Wert 10.130.0.0/23 ein.
  6. Klicken Sie auf Hinzufügen.

gcloud

Erstellen Sie das Nur-Proxy-Subnetz mit dem Befehl gcloud compute networks subnets create.

    gcloud compute networks subnets create PROXY_SN_A \
        --purpose=GLOBAL_MANAGED_PROXY \
        --role=ACTIVE \
        --region=REGION_A \
        --network=NETWORK \
        --range=10.129.0.0/23
    
    gcloud compute networks subnets create PROXY_SN_B \
        --purpose=GLOBAL_MANAGED_PROXY \
        --role=ACTIVE \
        --region=REGION_B \
        --network=NETWORK \
        --range=10.130.0.0/23

Terraform

Verwenden Sie die Ressource google_compute_subnetwork, um das VPC-Nur-Proxy-Subnetz im Netzwerk lb-network-crs-reg zu erstellen.

resource "google_compute_subnetwork" "proxy_subnet_a" {
  provider      = google-beta
  ip_cidr_range = "10.129.0.0/23"
  name          = "proxy-only-subnet1"
  network       = google_compute_network.default.id
  purpose       = "GLOBAL_MANAGED_PROXY"
  region        = "us-west1"
  role          = "ACTIVE"
  lifecycle {
    ignore_changes = [ipv6_access_type]
  }
}
 
resource "google_compute_subnetwork" "proxy_subnet_b" {
  provider      = google-beta
  ip_cidr_range = "10.130.0.0/23"
  name          = "proxy-only-subnet2"
  network       = google_compute_network.default.id
  purpose       = "GLOBAL_MANAGED_PROXY"
  region        = "us-east1"
  role          = "ACTIVE"
  lifecycle {
    ignore_changes = [ipv6_access_type]
  }
}

API

Erstellen Sie das Nur-Proxy-Subnetz mit der Methode subnetworks.insert und ersetzen Sie PROJECT_ID dabei durch Ihre Projekt-ID.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_A/subnetworks

    {
      "name": " PROXY_SN_A",
      "ipCidrRange": "10.129.0.0/23",
      "network": "projects/PROJECT_ID/global/networks/NETWORK",
      "region": "projects/PROJECT_ID/regions/REGION_A",
      "purpose": "GLOBAL_MANAGED_PROXY",
      "role": "ACTIVE"
    }
   
    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_B/subnetworks

    {
      "name": "PROXY_SN_B",
      "ipCidrRange": "10.130.0.0/23",
      "network": "projects/PROJECT_ID/global/networks/NETWORK",
      "region": "projects/PROJECT_ID/regions/REGION_B",
      "purpose": "GLOBAL_MANAGED_PROXY",
      "role": "ACTIVE"
    }

Firewallregeln konfigurieren

In diesem Beispiel werden die folgenden Firewallregeln verwendet:

  • fw-ilb-to-backends. Eine Regel für eingehenden Traffic, die für die Instanzen mit Load Balancing gilt und eingehende SSH-Verbindungen an TCP-Port 22 von jeder Adresse aus ermöglicht. Sie können einen restriktiveren IP-Quelladressbereich für diese Regel auswählen. Geben Sie dazu beispielsweise nur die IP-Adressbereiche des Systems an, von dem aus Sie SSH-Sitzungen initiieren. In diesem Beispiel wird das Ziel-Tag allow-ssh verwendet, um die VMs zu identifizieren, auf die die Firewallregel angewendet wird.

  • fw-healthcheck. Eine Regel für eingehenden Traffic, die für die Instanzen mit Load Balancing gilt und Traffic von den Google Cloud-Systemen für Systemdiagnosen zulässt (130.211.0.0/22 und 35.191.0.0/16). In diesem Beispiel wird das Ziel-Tag load-balanced-backend verwendet, um die VMs zu identifizieren, auf die die Firewallregel angewendet wird.

  • fw-backends. Eine Regel für eingehenden Traffic, die für die Instanzen mit Load Balancing gilt und TCP-Traffic über Port 80, 443 und 8080 und von den verwalteten Proxys des internen Application Load Balancers zulässt. In diesem Beispiel wird das Ziel-Tag load-balanced-backend verwendet, um die VMs zu identifizieren, auf die die Firewallregel angewendet wird.

Ohne diese Firewallregeln blockiert die Standardregel zum Ablehnen von eingehendem Traffic den eingehenden Traffic zu den Backend-Instanzen.

Die Back-End-Instanzen werden von den Ziel-Tags definiert. Ohne die Ziel-Tags gelten die Firewallregeln für alle Ihre Backend-Instanzen im VPC-Netzwerk. Achten Sie beim Erstellen der Back-End-VMs darauf, die angegebenen Ziel-Tags wie in Verwaltete Instanzgruppe erstellen beschrieben zu verwenden.

Console

  1. Rufen Sie in der Google Cloud Console die Seite der Firewall-Richtlinien auf.

    Zu den Firewall-Richtlinien

  2. Klicken Sie auf Firewallregel erstellen, um die Regel zu erstellen, die eingehende SSH-Verbindungen zulässt:

    • Name: fw-ilb-to-backends
    • Netzwerk: NETWORK
    • Trafficrichtung: Eingehend
    • Aktion bei Übereinstimmung: Zulassen
    • Ziele: Angegebene Ziel-Tags
    • Zieltags: allow-ssh
    • Quellfilter: IPv4-Bereiche.
    • IPv4-Quellbereiche: 0.0.0.0/0
    • Protokolle und Ports:
      • Wählen Sie Angegebene Protokolle und Ports aus.
      • Klicken Sie das Kästchen TCP an und geben Sie 22 als Portnummer ein.

  3. Klicken Sie auf Erstellen.

  4. Klicken Sie ein zweites Mal auf Firewallregel erstellen, um die Regel zum Zulassen von Google Cloud-Systemdiagnosen zu erstellen:

    • Name: fw-healthcheck
    • Netzwerk: NETWORK
    • Trafficrichtung: Eingehend
    • Aktion bei Übereinstimmung: Zulassen
    • Ziele: Angegebene Ziel-Tags
    • Zieltags: load-balanced-backend
    • Quellfilter: IPv4-Bereiche.
    • IPv4-Quellbereiche: 130.211.0.0/22 und 35.191.0.0/16

    • Protokolle und Ports:

      • Wählen Sie Angegebene Protokolle und Ports aus.
      • Klicken Sie das Kästchen TCP an und geben Sie 80 als Portnummer ein.

      Sie sollten diese Regeln nur auf Protokolle und Ports beschränken, die mit den von Ihren Systemdiagnosen verwendeten übereinstimmen. Wenn Sie tcp:80 für das Protokoll und den Port verwenden, kann Google Cloud mit HTTP auf Port 80 Ihre VMs kontaktieren. Es kann jedoch nicht HTTPS auf Port 443 verwenden, um den Kontakt herzustellen.

  5. Klicken Sie auf Erstellen.

  6. Klicken Sie ein drittes Mal auf Firewallregel erstellen, um die Regel zu erstellen, die Verbindungen von den Proxyservern des Load-Balancers zu den Back-Ends zulässt:

    • Name: fw-backends
    • Netzwerk: NETWORK
    • Trafficrichtung: Eingehend
    • Aktion bei Übereinstimmung: Zulassen
    • Ziele: Angegebene Ziel-Tags
    • Zieltags: load-balanced-backend
    • Quellfilter: IPv4-Bereiche.
    • IPv4-Quellbereiche: 10.129.0.0/23 und 10.130.0.0/23
    • Protokolle und Ports:
      • Wählen Sie Angegebene Protokolle und Ports aus.
      • Klicken Sie das Kästchen TCP an und geben Sie 80, 443, 8080 als Portnummer ein.

  7. Klicken Sie auf Erstellen.

gcloud

  1. Erstellen Sie die Firewallregel fw-ilb-to-backends, um SSH-Verbindungen zu VMs mit dem Netzwerk-Tag allow-ssh zu ermöglichen. Wenn Sie source-ranges weglassen, bezieht Google Cloud die Regel auf jede Quelle.

    gcloud compute firewall-rules create fw-ilb-to-backends \
    --network=NETWORK \
    --action=allow \
    --direction=ingress \
    --target-tags=allow-ssh \
    --rules=tcp:22

  2. Erstellen Sie die Regel fw-healthcheck, um Google Cloud-Systemdiagnosen zuzulassen. In diesem Beispiel wird der gesamte TCP-Traffic von Systemdiagnosetests zugelassen. Sie können jedoch Ihren Anforderungen entsprechend eine kleinere Gruppe von Ports konfigurieren:

    gcloud compute firewall-rules create fw-healthcheck \
    --network=NETWORK \
    --action=allow \
    --direction=ingress \
    --source-ranges=130.211.0.0/22,35.191.0.0/16 \
    --target-tags=load-balanced-backend \
    --rules=tcp

  3. Erstellen Sie die Regel fw-backends, um Verbindungen von den Proxys des internen Application Load Balancers zu Ihren Back-Ends zuzulassen. Legen Sie für source-ranges die zugewiesenen Bereiche des Nur-Proxy-Subnetzes fest, z. B. 10.129.0.0/23 und 10.130.0.0/23.

    gcloud compute firewall-rules create fw-backends \
    --network=NETWORK \
    --action=allow \
    --direction=ingress \
    --source-ranges=source-range \
    --target-tags=load-balanced-backend \
    --rules=tcp:80,tcp:443,tcp:8080

Terraform

Verwenden Sie zum Erstellen der Firewallregeln die Ressource google_compute_firewall.

resource "google_compute_firewall" "fw_healthcheck" {
  name          = "gl7-ilb-fw-allow-hc"
  provider      = google-beta
  direction     = "INGRESS"
  network       = google_compute_network.default.id
  source_ranges = ["130.211.0.0/22", "35.191.0.0/16", "35.235.240.0/20"]
  allow {
    protocol = "tcp"
  }
}
 
resource "google_compute_firewall" "fw_ilb_to_backends" {
  name          = "fw-ilb-to-fw"
  provider      = google-beta
  network       = google_compute_network.default.id
  source_ranges = ["0.0.0.0/0"]
  allow {
    protocol = "tcp"
    ports    = ["22", "80", "443", "8080"]
  }
}
 
resource "google_compute_firewall" "fw_backends" {
  name          = "gl7-ilb-fw-allow-ilb-to-backends"
  direction     = "INGRESS"
  network       = google_compute_network.default.id
  source_ranges = ["10.129.0.0/23", "10.130.0.0/23"]
  target_tags   = ["http-server"]
  allow {
    protocol = "tcp"
    ports    = ["80", "443", "8080"]
  }
}

API

Erstellen Sie die Firewallregel fw-ilb-to-backends durch Senden einer POST-Anfrage an die Methode firewalls.insert. Ersetzen Sie dabei PROJECT_ID durch Ihre Projekt-ID.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls

{
 "name": "fw-ilb-to-backends",
 "network": "projects/PROJECT_ID/global/networks/NETWORK",
 "sourceRanges": [
   "0.0.0.0/0"
 ],
 "targetTags": [
   "allow-ssh"
 ],
 "allowed": [
  {
    "IPProtocol": "tcp",
    "ports": [
      "22"
    ]
  }
 ],
"direction": "INGRESS"
}

Erstellen Sie die Firewallregel fw-healthcheck durch Senden einer POST-Anfrage an die Methode firewalls.insert. Ersetzen Sie dabei PROJECT_ID durch Ihre Projekt-ID.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls

{
 "name": "fw-healthcheck",
 "network": "projects/PROJECT_ID/global/networks/NETWORK",
 "sourceRanges": [
   "130.211.0.0/22",
   "35.191.0.0/16"
 ],
 "targetTags": [
   "load-balanced-backend"
 ],
 "allowed": [
   {
     "IPProtocol": "tcp"
   }
 ],
 "direction": "INGRESS"
}

Erstellen Sie die Firewallregel fw-backends, um TCP-Traffic im Proxy-Subnetz für die Methode firewalls.insert zuzulassen. Ersetzen Sie dabei PROJECT_ID durch Ihre Projekt-ID.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls

{
 "name": "fw-backends",
 "network": "projects/PROJECT_ID/global/networks/NETWORK",
 "sourceRanges": [
   "10.129.0.0/23",
   "10.130.0.0/23"
 ],
 "targetTags": [
   "load-balanced-backend"
 ],
 "allowed": [
   {
     "IPProtocol": "tcp",
     "ports": [
       "80"
     ]
   },
 {
     "IPProtocol": "tcp",
     "ports": [
       "443"
     ]
   },
   {
     "IPProtocol": "tcp",
     "ports": [
       "8080"
     ]
   }
 ],
 "direction": "INGRESS"
}

Erstellen Sie eine verwaltete Instanzgruppe.

In diesem Abschnitt wird gezeigt, wie Sie eine Vorlage und eine verwaltete Instanzgruppe erstellen. Die verwaltete Instanzgruppe stellt VM-Instanzen bereit, auf denen die Backend-Server eines beispielhaften regionenübergeifenden internen Application Load Balancers ausgeführt werden. Für Ihre Instanzgruppe können Sie einen HTTP-Dienst definieren und dem entsprechenden Port einen Portnamen zuordnen. Der Backend-Dienst des Load-Balancers leitet den Traffic an den benannten Port weiter. Der Traffic von Clients wird auf Backend-Server verteilt. Zur Veranschaulichung stellen Back-Ends ihre eigenen Hostnamen bereit.

Console

  1. Rufen Sie in der Google Cloud Console die Seite Instanzvorlagen auf.

    Zu Instanzvorlagen

    1. Klicken Sie auf Instanzvorlage erstellen.
    2. Geben Sie für Name gil7-backendeast1-template ein.
    3. Das Bootlaufwerk sollte auf ein Debian-Image wie Debian GNU/Linux 12 (bookworm) eingestellt sein. Diese Anleitungen verwenden Befehle, die nur für Debian verfügbar sind, z. B. apt-get.
    4. Klicken Sie auf Erweiterte Optionen.
    5. Klicken Sie auf Netzwerk und konfigurieren Sie die folgenden Felder:
      1. Geben Sie für Netzwerk-Tags allow-ssh und load-balanced-backend ein.
      2. Wählen Sie für Netzwerkschnittstellen Folgendes aus:
        • Netzwerk: NETWORK
        • Subnetz: SUBNET_B

    6. Klicken Sie auf Verwaltung. Fügen Sie im Feld Startskript das nachfolgende Skript ein.

      #! /bin/bash
apt-get update
apt-get install apache2 -y
a2ensite default-ssl
a2enmod ssl
vm_hostname="$(curl -H "Metadata-Flavor:Google" \
http://169.254.169.254/computeMetadata/v1/instance/name)"
echo "Page served from: $vm_hostname" | \
tee /var/www/html/index.html
systemctl restart apache2

    7. Klicken Sie auf Erstellen.

    8. Klicken Sie auf Instanzvorlage erstellen.

    9. Geben Sie für Name gil7-backendwest1-template ein.

    10. Das Bootlaufwerk sollte auf ein Debian-Image wie Debian GNU/Linux 12 (bookworm) eingestellt sein. Diese Anleitungen verwenden Befehle, die nur für Debian verfügbar sind, z. B. apt-get.

    11. Klicken Sie auf Erweiterte Optionen.

    12. Klicken Sie auf Netzwerk und konfigurieren Sie die folgenden Felder:

      1. Geben Sie für Netzwerk-Tags allow-ssh und load-balanced-backend ein.
      2. Wählen Sie für Netzwerkschnittstellen Folgendes aus:
        • Netzwerk: NETWORK
        • Subnetz: SUBNET_A

    13. Klicken Sie auf Verwaltung. Fügen Sie im Feld Startskript das nachfolgende Skript ein.

      #! /bin/bash
apt-get update
apt-get install apache2 -y
a2ensite default-ssl
a2enmod ssl
vm_hostname="$(curl -H "Metadata-Flavor:Google" \
http://169.254.169.254/computeMetadata/v1/instance/name)"
echo "Page served from: $vm_hostname" | \
tee /var/www/html/index.html
systemctl restart apache2

    14. Klicken Sie auf Erstellen.

  2. Rufen Sie in der Google Cloud Console die Seite Instanzgruppen auf.

    Zu den Instanzgruppen

    1. Klicken Sie auf Instanzgruppe erstellen.
    2. Wählen Sie Neue verwaltete Instanzgruppe (zustandslos) aus. Weitere Informationen finden Sie unter Zustandslose oder zustandsorientierte MIGs.
    3. Geben Sie für Name gl7-ilb-mig-a ein.
    4. Wählen Sie für Standort die Option Einzelne Zone aus.
    5. Wählen Sie bei Region die Option REGION_A aus.
    6. Wählen Sie bei Zone die Option ZONE_A aus.
    7. Wählen Sie bei Instanzvorlage die Option gil7-backendwest1-template aus.

    8. Geben Sie an, wie viele Instanzen die Gruppe umfassen soll.

      Geben Sie für dieses Beispiel unter Autoscaling die folgenden Optionen an:

      • Wählen Sie für Autoscaling-Modus Off:do not autoscale aus.
      • Geben Sie für Maximale Anzahl von Instanzen den Wert 2 ein.

      Optional können Sie im Abschnitt Autoscaling der Benutzeroberfläche die Instanzgruppe so konfigurieren, dass Instanzen basierend auf der CPU-Auslastung automatisch hinzugefügt oder entfernt werden.

    9. Klicken Sie auf Erstellen.

    10. Klicken Sie auf Instanzgruppe erstellen.

    11. Wählen Sie Neue verwaltete Instanzgruppe (zustandslos) aus. Weitere Informationen finden Sie unter Zustandslose oder zustandsorientierte MIGs.

    12. Geben Sie für Name gl7-ilb-mig-b ein.

    13. Wählen Sie für Standort die Option Einzelne Zone aus.

    14. Wählen Sie bei Region die Option REGION_B aus.

    15. Wählen Sie bei Zone die Option ZONE_B aus.

    16. Wählen Sie bei Instanzvorlage die Option gil7-backendeast1-template aus.

    17. Geben Sie an, wie viele Instanzen die Gruppe umfassen soll.

      Geben Sie für dieses Beispiel unter Autoscaling die folgenden Optionen an:

      • Wählen Sie für Autoscaling-Modus Off:do not autoscale aus.
      • Geben Sie für Maximale Anzahl von Instanzen den Wert 2 ein.

      Optional können Sie im Abschnitt Autoscaling der Benutzeroberfläche die Instanzgruppe so konfigurieren, dass Instanzen basierend auf der CPU-Auslastung automatisch hinzugefügt oder entfernt werden.

    18. Klicken Sie auf Erstellen.

gcloud

Bei den gcloud CLI-Anleitungen in diesem Handbuch wird davon ausgegangen, dass Sie Cloud Shell oder eine andere Umgebung verwenden, in der Bash installiert ist.

  1. Erstellen Sie mit dem Befehl gcloud compute instance-templates create eine VM-Instanzvorlage mit HTTP-Server.

    gcloud compute instance-templates create gil7-backendwest1-template \
  --region=REGION_A \
  --network=NETWORK \
  --subnet=SUBNET_A \
  --tags=allow-ssh,load-balanced-backend \
  --image-family=debian-12 \
  --image-project=debian-cloud \
  --metadata=startup-script='#! /bin/bash
    apt-get update
    apt-get install apache2 -y
    a2ensite default-ssl
    a2enmod ssl
    vm_hostname="$(curl -H "Metadata-Flavor:Google" \
    http://169.254.169.254/computeMetadata/v1/instance/name)"
    echo "Page served from: $vm_hostname" | \
    tee /var/www/html/index.html
    systemctl restart apache2'

    gcloud compute instance-templates create gil7-backendeast1-template \
    --region=REGION_B \
    --network=NETWORK \
    --subnet=SUBNET_B \
    --tags=allow-ssh,load-balanced-backend \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --metadata=startup-script='#! /bin/bash
      apt-get update
      apt-get install apache2 -y
      a2ensite default-ssl
      a2enmod ssl
      vm_hostname="$(curl -H "Metadata-Flavor:Google" \
      http://169.254.169.254/computeMetadata/v1/instance/name)"
      echo "Page served from: $vm_hostname" | \
      tee /var/www/html/index.html
      systemctl restart apache2'

  2. Erstellen Sie mit dem Befehl gcloud compute instance-groups managed create eine verwaltete Instanzgruppe in der Zone.

    gcloud compute instance-groups managed create gl7-ilb-mig-a \
    --zone=ZONE_A \
    --size=2 \
    --template=gil7-backendwest1-template

    gcloud compute instance-groups managed create gl7-ilb-mig-b \
    --zone=ZONE_B \
    --size=2 \
    --template=gil7-backendeast1-template

Terraform

Verwenden Sie zum Erstellen der Instanzvorlage die Ressource google_compute_instance_template.

resource "google_compute_instance_template" "instance_template_a" {
  name         = "gil7-backendwest1-template"
  provider     = google-beta
  machine_type = "e2-small"
  region       = "us-west1"
  tags         = ["http-server"]

  network_interface {
    network    = google_compute_network.default.id
    subnetwork = google_compute_subnetwork.subnet_a.id
    access_config {
      # add external ip to fetch packages
    }
  }
  disk {
    source_image = "debian-cloud/debian-11"
    auto_delete  = true
    boot         = true
  }

  # install nginx and serve a simple web page
  metadata = {
    startup-script = <<-EOF1
      #! /bin/bash
      set -euo pipefail

      export DEBIAN_FRONTEND=noninteractive
      apt-get update
      apt-get install -y nginx-light jq

      NAME=$(curl -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/hostname")
      IP=$(curl -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/network-interfaces/0/ip")
      METADATA=$(curl -f -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/attributes/?recursive=True" | jq 'del(.["startup-script"])')

      cat <<EOF > /var/www/html/index.html
      <pre>
      Name: $NAME
      IP: $IP
      Metadata: $METADATA
      </pre>
      EOF
    EOF1
  }
  lifecycle {
    create_before_destroy = true
  }
}
 
resource "google_compute_instance_template" "instance_template_b" {
  name         = "gil7-backendeast1-template"
  provider     = google-beta
  machine_type = "e2-small"
  region       = "us-east1"
  tags         = ["http-server"]

  network_interface {
    network    = google_compute_network.default.id
    subnetwork = google_compute_subnetwork.subnet_b.id
    access_config {
      # add external ip to fetch packages
    }
  }
  disk {
    source_image = "debian-cloud/debian-11"
    auto_delete  = true
    boot         = true
  }

  # install nginx and serve a simple web page
  metadata = {
    startup-script = <<-EOF1
      #! /bin/bash
      set -euo pipefail

      export DEBIAN_FRONTEND=noninteractive
      apt-get update
      apt-get install -y nginx-light jq

      NAME=$(curl -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/hostname")
      IP=$(curl -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/network-interfaces/0/ip")
      METADATA=$(curl -f -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/attributes/?recursive=True" | jq 'del(.["startup-script"])')

      cat <<EOF > /var/www/html/index.html
      <pre>
      Name: $NAME
      IP: $IP
      Metadata: $METADATA
      </pre>
      EOF
    EOF1
  }
  lifecycle {
    create_before_destroy = true
  }
}

Verwenden Sie zum Erstellen der verwalteten Instanzgruppe die Ressource google_compute_instance_group_manager.

resource "google_compute_region_instance_group_manager" "mig_a" {
  name     = "gl7-ilb-miga"
  provider = google-beta
  region   = "us-west1"
  version {
    instance_template = google_compute_instance_template.instance_template_a.id
    name              = "primary"
  }
  base_instance_name = "vm"
  target_size        = 2
}
 
resource "google_compute_region_instance_group_manager" "mig_b" {
  name     = "gl7-ilb-migb"
  provider = google-beta
  region   = "us-east1"
  version {
    instance_template = google_compute_instance_template.instance_template_b.id
    name              = "primary"
  }
  base_instance_name = "vm"
  target_size        = 2
}

API

Erstellen Sie mit der Methode instanceTemplates.insert die Instanzvorlage. Ersetzen Sie dabei PROJECT_ID durch Ihre Projekt-ID.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/instanceTemplates

{
  "name":"gil7-backendwest1-template",
  "properties":{
     "machineType":"e2-standard-2",
     "tags":{
       "items":[
         "allow-ssh",
         "load-balanced-backend"
       ]
     },
     "metadata":{
        "kind":"compute#metadata",
        "items":[
          {
            "key":"startup-script",
            "value":"#! /bin/bash\napt-get update\napt-get install
            apache2 -y\na2ensite default-ssl\na2enmod ssl\n
            vm_hostname=\"$(curl -H \"Metadata-Flavor:Google\"
            \\\nhttp://169.254.169.254/computeMetadata/v1/instance/name)\"\n
            echo \"Page served from: $vm_hostname\" | \\\ntee
            /var/www/html/index.html\nsystemctl restart apache2"
          }
        ]
     },
     "networkInterfaces":[
       {
         "network":"projects/PROJECT_ID/global/networks/NETWORK",
         "subnetwork":"regions/REGION_A/subnetworks/SUBNET_A",
         "accessConfigs":[
           {
             "type":"ONE_TO_ONE_NAT"
           }
         ]
       }
     ],
     "disks":[
       {
         "index":0,
         "boot":true,
         "initializeParams":{
           "sourceImage":"projects/debian-cloud/global/images/family/debian-12"
         },
         "autoDelete":true
       }
     ]
  }
}

Erstellen Sie mit der Methode instanceGroupManagers.insert in jeder Zone eine verwaltete Instanzgruppe. Ersetzen Sie dabei PROJECT_ID durch Ihre Projekt-ID.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/{zone}/instanceGroupManagers

{
  "name": "gl7-ilb-mig-a",
  "zone": "projects/PROJECT_ID/zones/ZONE_A",
  "instanceTemplate": "projects/PROJECT_ID/global/instanceTemplates/gil7-backendwest1-template",
  "baseInstanceName": "gl7-ilb-mig-b",
  "targetSize": 2
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/instanceTemplates

{
  "name":"gil7-backendeast1-template",
  "properties":{
     "machineType":"e2-standard-2",
     "tags":{
       "items":[
         "allow-ssh",
         "load-balanced-backend"
       ]
     },
     "metadata":{
        "kind":"compute#metadata",
        "items":[
          {
            "key":"startup-script",
            "value":"#! /bin/bash\napt-get update\napt-get install
            apache2 -y\na2ensite default-ssl\na2enmod ssl\n
            vm_hostname=\"$(curl -H \"Metadata-Flavor:Google\"
            \\\nhttp://169.254.169.254/computeMetadata/v1/instance/name)\"\n
            echo \"Page served from: $vm_hostname\" | \\\ntee
            /var/www/html/index.html\nsystemctl restart apache2"
          }
        ]
     },
     "networkInterfaces":[
       {
         "network":"projects/PROJECT_ID/global/networks/NETWORK",
         "subnetwork":"regions/REGION_B/subnetworks/SUBNET_B",
         "accessConfigs":[
           {
             "type":"ONE_TO_ONE_NAT"
           }
         ]
       }
     ],
     "disks":[
       {
         "index":0,
         "boot":true,
         "initializeParams":{
           "sourceImage":"projects/debian-cloud/global/images/family/debian-12"
         },
         "autoDelete":true
       }
     ]
  }
}

Erstellen Sie mit der Methode instanceGroupManagers.insert in jeder Zone eine verwaltete Instanzgruppe. Ersetzen Sie dabei PROJECT_ID durch Ihre Projekt-ID.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/{zone}/instanceGroupManagers

{
  "name": "gl7-ilb-mig-b",
  "zone": "projects/PROJECT_ID/zones/ZONE_B",
  "instanceTemplate": "projects/PROJECT_ID/global/instanceTemplates/gil7-backendwest1-template",
  "baseInstanceName": "gl7-ilb-mig-b",
  "targetSize": 2
}

Load-Balancer konfigurieren

In diesem Beispiel wird gezeigt, wie Sie die folgenden Ressourcen für den regionenübergreifenden internen Application Load Balancer erstellen:

  • Eine globale HTTP-Systemdiagnose.
  • Globaler Back-End-Dienst mit den verwalteten Instanzgruppen als Back-End
  • Eine URL-Zuordnung. Verweisen Sie auf eine globale URL-Zuordnung für den HTTP(S)-Zielproxy. Eine globale URL-Zuordnung leitet Anfragen an einen globalen Backend-Dienst auf Grundlage von Regeln weiter, die Sie für den Host und den Pfad einer eingehenden URL definieren. Eine globale URL-Zuordnung kann von einer globalen Zielproxy-Regel referenziert werden.
  • Ein globales SSL-Zertifikat (für HTTPS).
  • Einen globalen Ziel-Proxy.

  • Zwei globale Weiterleitungsregeln mit regionalen IP-Adressen. Verwenden Sie für die IP-Adresse der Weiterleitungsregel den IP-Adressbereich SUBNET_A oder SUBNET_B. Wenn Sie das Nur-Proxy-Subnetz verwenden, schlägt das Erstellen der Weiterleitungsregel fehl.

Console

Konfiguration starten

  1. Rufen Sie in der Google Cloud Console die Seite Load-Balancing auf.

    Load-Balancing aufrufen

  2. Klicken Sie auf Load-Balancer erstellen.
  3. Wählen Sie unter Typ des Load Balancers die Option Application Load Balancer (HTTP/HTTPS) aus und klicken Sie auf Weiter.
  4. Wählen Sie für Öffentlich oder intern die Option Intern aus und klicken Sie auf Weiter.
  5. Wählen Sie für Regionenübergreifende oder Einzelregions-Bereitstellung die Option Best für regionenübergreifende Arbeitslasten aus und klicken Sie auf Weiter.
  6. Klicken Sie auf Konfigurieren.

Grundlegende Konfiguration

  1. Geben Sie einen Namen für den Load Balancer an.
  2. Wählen Sie für Netzwerk die Option NETWORK aus.

Frontend mit zwei Weiterleitungsregeln konfigurieren

Bei HTTP:

  1. Klicken Sie auf Front-End-Konfiguration.
    1. Geben Sie einen Namen für die Weiterleitungsregel an.
    2. Wählen Sie in der Liste Subnetzwerkregion die Option REGION_A aus.

      Nur-Proxy-Subnetz reservieren

    3. Wählen Sie in der Liste Subnetzwerk die Option SUBNET_A aus.
    4. Klicken Sie in der Liste IP-Adresse auf IP-Adresse erstellen. Die Seite Statische interne IP-Adresse reservieren wird geöffnet.
      • Geben Sie einen Namen für die statische IP-Adresse an.
      • Wählen Sie im Abschnitt Statische IP-Adresse die Option Selbst auswählen aus.
      • Geben Sie im Abschnitt Benutzerdefinierte IP-Adresse 10.1.2.99 ein.
      • Wählen Sie Reservieren aus.
  2. Klicken Sie auf Fertig.
  3. Klicken Sie auf Front-End-IP und -Port hinzufügen, um die zweite Weiterleitungsregel hinzuzufügen.
    1. Geben Sie einen Namen für die Weiterleitungsregel an.
    2. Wählen Sie in der Liste Subnetzwerkregion die Option REGION_B aus.

      Nur-Proxy-Subnetz reservieren

    3. Wählen Sie in der Liste Subnetzwerk die Option SUBNET_B aus.
    4. Klicken Sie in der Liste IP-Adresse auf IP-Adresse erstellen. Die Seite Statische interne IP-Adresse reservieren wird geöffnet.
      • Geben Sie einen Namen für die statische IP-Adresse an.
      • Wählen Sie im Abschnitt Statische IP-Adresse die Option Selbst auswählen aus.
      • Geben Sie im Abschnitt Benutzerdefinierte IP-Adresse 10.1.3.99 ein.
      • Wählen Sie Reservieren aus.
  4. Klicken Sie auf Fertig.

Bei HTTPS:

Wenn Sie HTTPS zwischen dem Client und dem Load-Balancer verwenden, benötigen Sie eine oder mehrere SSL-Zertifikatsressourcen, um den Proxy zu konfigurieren. Informationen zum Erstellen eines all-regions von Google verwalteten Zertifikats finden Sie in der folgenden Dokumentation:

Nachdem Sie das von Google verwaltete Zertifikat erstellt haben, hängen Sie das Zertifikat direkt an den Zielproxy an. Zertifikatzuordnungen werden nicht von regionsübergreifenden internen Application Load Balancern unterstützt.

Informationen zum Erstellen eines selbstverwalteten all-regions-Zertifikats finden Sie in der folgenden Dokumentation: Regionales selbstverwaltetes Zertifikat bereitstellen.

  1. Klicken Sie auf Front-End-Konfiguration.
    1. Geben Sie einen Namen für die Weiterleitungsregel an.
    2. Wählen Sie im Feld Protokoll die Option HTTPS (includes HTTP/2) aus.
    3. Achten Sie darauf, dass der Port auf 443 festgelegt ist.
    4. Wählen Sie in der Liste Subnetzwerkregion die Option REGION_A aus.

      Nur-Proxy-Subnetz reservieren

    5. Wählen Sie in der Liste Subnetzwerk die Option SUBNET_A aus.
    6. Klicken Sie in der Liste IP-Adresse auf IP-Adresse erstellen. Die Seite Statische interne IP-Adresse reservieren wird geöffnet.
      • Geben Sie einen Namen für die statische IP-Adresse an.
      • Wählen Sie im Abschnitt Statische IP-Adresse die Option Selbst auswählen aus.
      • Geben Sie im Abschnitt Benutzerdefinierte IP-Adresse 10.1.3.99 ein.
      • Wählen Sie Reservieren aus.
    7. Wählen Sie im Abschnitt Zertifikat hinzufügen das Zertifikat aus.
    8. Optional: So fügen Sie zusätzlich zum primären SSL-Zertifikat Zertifikate hinzu:
      1. Klicken Sie auf Zertifikat hinzufügen.
      2. Wählen Sie das Zertifikat aus der Liste aus.
    9. Wählen Sie aus der Liste SSL-Richtlinie eine SSL-Richtlinie aus. Wenn Sie keine SSL-Richtlinien erstellt haben, wird eine Google Cloud-SSL-Standardrichtlinie angewendet.
    10. Klicken Sie auf Fertig.

    Fügen Sie die zweite Frontend-Konfiguration hinzu:

    1. Geben Sie einen Namen für die Front-End-Konfiguration an.
    2. Wählen Sie im Feld Protokoll die Option HTTPS (includes HTTP/2) aus.
    3. Achten Sie darauf, dass der Port auf 443 festgelegt ist.
    4. Wählen Sie in der Liste Subnetzwerkregion die Option REGION_B aus.

      Nur-Proxy-Subnetz reservieren

    5. Wählen Sie in der Liste Subnetzwerk die Option SUBNET_B aus.
    6. Klicken Sie in der Liste IP-Adresse auf IP-Adresse erstellen. Die Seite Statische interne IP-Adresse reservieren wird geöffnet.
      • Geben Sie einen Namen für die statische IP-Adresse an.
      • Wählen Sie im Abschnitt Statische IP-Adresse die Option Selbst auswählen aus.
      • Geben Sie im Abschnitt Benutzerdefinierte IP-Adresse 10.1.3.99 ein.
      • Wählen Sie Reservieren aus.
    7. Wählen Sie im Abschnitt Zertifikat hinzufügen das Zertifikat aus.
    8. Optional: So fügen Sie zusätzlich zum primären SSL-Zertifikat Zertifikate hinzu:
      1. Klicken Sie auf Zertifikat hinzufügen.
      2. Wählen Sie das Zertifikat aus der Liste aus.
    9. Wählen Sie aus der Liste SSL-Richtlinie eine SSL-Richtlinie aus. Wenn Sie keine SSL-Richtlinien erstellt haben, wird eine Google Cloud-SSL-Standardrichtlinie angewendet.
    10. Klicken Sie auf Fertig.
    Backend-Dienst konfigurieren
    1. Klicken Sie auf Backend-Konfiguration.
    2. Klicken Sie in der Liste Backend-Dienste erstellen oder auswählen auf Backend-Dienst erstellen.
    3. Geben Sie einen Namen für den Backend-Dienst an.
    4. Wählen Sie für Protokoll die Option HTTP aus.
    5. Geben Sie als Benannter Port http ein.
    6. Wählen Sie in der Liste Backend-Typ die Option Instanzgruppe aus.
    7. Im Abschnitt Neues Backend:
      • Wählen Sie in der Liste Instanzgruppe in REGION_A die Option gl4-ilb-miga aus.
      • Legen Sie für Portnummern den Wert 80 fest.
      • Klicken Sie auf Fertig.
      • Klicken Sie auf Backend hinzufügen, um ein weiteres Backend hinzuzufügen.
      • Wählen Sie in der Liste Instanzgruppe in REGION_B die Option gl4-ilb-migb aus.
      • Legen Sie für Portnummern den Wert 80 fest.
      • Klicken Sie auf Fertig.
    8. Klicken Sie im Abschnitt Systemdiagnose auf Systemdiagnose erstellen.
      • Geben Sie im Feld Name global-http-health-check ein.
      • Legen Sie für Protokoll den Wert HTTP fest.
      • Legen Sie für Port den Wert 80 fest.
      • Klicken Sie auf Speichern.

    Routingregeln konfigurieren

    1. Klicken Sie auf Routingregeln.
    2. Wählen Sie unter Modus die Option Einfache Host- und Pfadregel aus.
    3. Achten Sie darauf, dass für alle nicht übereinstimmenden Hosts und alle nicht übereinstimmenden Pfade nur ein Backend-Dienst vorhanden ist.

    Konfiguration prüfen

    1. Klicken Sie auf Prüfen und abschließen.
    2. Prüfen Sie die Konfigurationseinstellungen des Load-Balancers.
    3. Klicken Sie auf Erstellen.

gcloud

  1. Definieren Sie die HTTP-Systemdiagnose mit dem Befehl gcloud compute health-checks create http.

    gcloud compute health-checks create http global-http-health-check \
   --use-serving-port \
   --global

  2. Definieren Sie den Backend-Dienst mit dem Befehl gcloud compute backend-services create.

    gcloud compute backend-services create BACKEND_SERVICE_NAME \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --protocol=HTTP \
  --enable-logging \
  --logging-sample-rate=1.0 \
  --health-checks=global-http-health-check \
  --global-health-checks \
  --global

  3. Fügen Sie dem Backend-Dienst mit dem Befehl gcloud compute backend-services add-backend Backends hinzu.

    gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
  --balancing-mode=UTILIZATION \
  --instance-group=gl7-ilb-mig-a \
  --instance-group-zone=ZONE_A \
  --global

    gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
  --balancing-mode=UTILIZATION \
  --instance-group=gl7-ilb-mig-b \
  --instance-group-zone=ZONE_B \
  --global

  4. Erstellen Sie die URL-Zuordnung mit dem Befehl gcloud compute url-maps create.

    gcloud compute url-maps create gl7-gilb-url-map \
  --default-service=BACKEND_SERVICE_NAME \
  --global

  5. Erstellen Sie den Zielproxy.

    Bei HTTP:

    Erstellen Sie den Zielproxy mit dem Befehl gcloud compute target-http-proxies create.

    gcloud compute target-http-proxies create gil7-http-proxy \
  --url-map=gl7-gilb-url-map \
  --global

    Bei HTTPS:

    Informationen zum Erstellen eines von Google verwalteten Zertifikats finden Sie in der folgenden Dokumentation:

    Nachdem Sie das von Google verwaltete Zertifikat erstellt haben, hängen Sie das Zertifikat direkt an den Zielproxy an. Zertifikatzuordnungen werden nicht von regionsübergreifenden internen Application Load Balancern unterstützt.

    Informationen zum Erstellen eines selbstverwalteten Zertifikats finden Sie in der folgenden Dokumentation:

    Weisen Sie Ihre Dateipfade den entsprechenden Variablennamen zu.

    export LB_CERT=PATH_TO_PEM_FORMATTED_FILE

    export LB_PRIVATE_KEY=PATH_TO_LB_PRIVATE_KEY_FILE

    Erstellen Sie mit dem Befehl gcloud beta certificate-manager certificates create ein SSL-Zertifikat für alle Regionen.

    gcloud certificate-manager certificates create gilb-certificate \
  --private-key-file=$LB_PRIVATE_KEY \
  --certificate-file=$LB_CERT \
  --scope=all-regions

    Verwenden Sie das regionale SSL-Zertifikat, um mit dem Befehl gcloud compute target-https-proxies create einen Zielproxy zu erstellen.

    gcloud compute target-https-proxies create gil7-https-proxy \
  --url-map=gl7-gilb-url-map \
  --certificate-manager-certificates=gilb-certificate \
  --global

  6. Erstellen Sie zwei Weiterleitungsregeln, eine mit einer VIP (10.1.2.99) in der Region REGION_B und eine andere mit einer VIP (10.1.3.99) in der Region REGION_A. Weitere Informationen finden Sie unter Statische interne IPv4-Adresse reservieren.

    Bei benutzerdefinierten Netzwerken müssen Sie in der Weiterleitungsregel auf das Subnetz verweisen. Achten Sie darauf, dass dies das VM-Subnetz und nicht das Proxy-Subnetz ist.

    Bei HTTP:

    Verwenden Sie den Befehl gcloud compute forwarding-rules create mit den richtigen Flags.

    gcloud compute forwarding-rules create FWRULE_A \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=NETWORK \
  --subnet=SUBNET_A \
  --subnet-region=REGION_A \
  --address=10.1.2.99 \
  --ports=80 \
  --target-http-proxy=gil7-http-proxy \
  --global

    gcloud compute forwarding-rules create FWRULE_B \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=NETWORK \
  --subnet=SUBNET_B \
  --subnet-region=REGION_B \
  --address=10.1.3.99 \
  --ports=80 \
  --target-http-proxy=gil7-http-proxy \
  --global

    Bei HTTPS:

    Verwenden Sie den Befehl gcloud compute forwarding-rules create mit den richtigen Flags.

    gcloud compute forwarding-rules create FWRULE_A \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=NETWORK \
  --subnet=SUBNET_A \
  --subnet-region=REGION_A \
  --address=10.1.2.99 \
  --ports=443 \
  --target-https-proxy=gil7-https-proxy \
  --global

    gcloud compute forwarding-rules create FWRULE_B \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=NETWORK \
  --subnet=SUBNET_B \
  --subnet-region=REGION_B \
  --address=10.1.3.99 \
  --ports=443 \
  --target-https-proxy=gil7-https-proxy \
  --global

Terraform

Verwenden Sie zum Erstellen der Systemdiagnose die Ressource google_compute_health_check.

resource "google_compute_health_check" "default" {
  provider = google-beta
  name     = "global-http-health-check"
  http_health_check {
    port_specification = "USE_SERVING_PORT"
  }
}

Verwenden Sie zum Erstellen des Backend-Dienstes die Ressource google_compute_backend_service.

resource "google_compute_backend_service" "default" {
  name                  = "gl7-gilb-backend-service"
  provider              = google-beta
  protocol              = "HTTP"
  load_balancing_scheme = "INTERNAL_MANAGED"
  timeout_sec           = 10
  health_checks         = [google_compute_health_check.default.id]
  backend {
    group           = google_compute_region_instance_group_manager.mig_a.instance_group
    balancing_mode  = "UTILIZATION"
    capacity_scaler = 1.0
  }
  backend {
    group           = google_compute_region_instance_group_manager.mig_b.instance_group
    balancing_mode  = "UTILIZATION"
    capacity_scaler = 1.0
  }
}

Verwenden Sie zum Erstellen der URL-Zuordnung die Ressource google_compute_url_map.

resource "google_compute_url_map" "default" {
  name            = "gl7-gilb-url-map"
  provider        = google-beta
  default_service = google_compute_backend_service.default.id
}

Verwenden Sie zum Erstellen des Ziel-HTTP-Proxys die Ressource google_compute_target_http_proxy.

resource "google_compute_target_http_proxy" "default" {
  name     = "gil7target-http-proxy"
  provider = google-beta
  url_map  = google_compute_url_map.default.id
}

Verwenden Sie zum Erstellen der Weiterleitungsregel die Ressource google_compute_forwarding_rule.

resource "google_compute_global_forwarding_rule" "fwd_rule_a" {
  provider              = google-beta
  depends_on            = [google_compute_subnetwork.proxy_subnet_a]
  ip_address            = "10.1.2.99"
  ip_protocol           = "TCP"
  load_balancing_scheme = "INTERNAL_MANAGED"
  name                  = "gil7forwarding-rule-a"
  network               = google_compute_network.default.id
  port_range            = "80"
  target                = google_compute_target_http_proxy.default.id
  subnetwork            = google_compute_subnetwork.subnet_a.id
}
 
resource "google_compute_global_forwarding_rule" "fwd_rule_b" {
  provider              = google-beta
  depends_on            = [google_compute_subnetwork.proxy_subnet_b]
  ip_address            = "10.1.3.99"
  ip_protocol           = "TCP"
  load_balancing_scheme = "INTERNAL_MANAGED"
  name                  = "gil7forwarding-rule-b"
  network               = google_compute_network.default.id
  port_range            = "80"
  target                = google_compute_target_http_proxy.default.id
  subnetwork            = google_compute_subnetwork.subnet_b.id
}

Informationen zum Anwenden oder Entfernen einer Terraform-Konfiguration finden Sie unter Grundlegende Terraform-Befehle.

API

Erstellen Sie die Systemdiagnose durch Senden einer POST-Anfrage an die Methode healthChecks.insert. Ersetzen Sie dabei PROJECT_ID durch Ihre Projekt-ID.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/healthChecks

{
"name": "global-http-health-check",
"type": "HTTP",
"httpHealthCheck": {
  "portSpecification": "USE_SERVING_PORT"
}
}

Erstellen Sie den globalen Backend-Dienst durch Senden einer POST-Anfrage an die Methode backendServices.insert. Ersetzen Sie dabei PROJECT_ID durch Ihre Projekt-ID.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/backendServices

{
"name": "BACKEND_SERVICE_NAME",
"backends": [
  {
    "group": "projects/PROJECT_ID/zones/ZONE_A/instanceGroups/gl7-ilb-mig-a",
    "balancingMode": "UTILIZATION"
  },
  {
    "group": "projects/PROJECT_ID/zones/ZONE_B/instanceGroups/gl7-ilb-mig-b",
    "balancingMode": "UTILIZATION"
  }
],
"healthChecks": [
  "projects/PROJECT_ID/regions/global/healthChecks/global-http-health-check"
],
"loadBalancingScheme": "INTERNAL_MANAGED"
}

Erstellen Sie die URL-Zuordnung durch Senden einer POST-Anfrage an die Methode urlMaps.insert. Ersetzen Sie dabei PROJECT_ID durch Ihre Projekt-ID.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/urlMaps

{
"name": "l7-ilb-map",
"defaultService": "projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_NAME"
}

Bei HTTP:

Erstellen Sie den Ziel-HTTP-Proxy durch Senden einer POST-Anfrage an die Methode targetHttpProxies.insert. Ersetzen Sie dabei PROJECT_ID durch Ihre Projekt-ID.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/targetHttpProxy

{
"name": "l7-ilb-proxy",
"urlMap": "projects/PROJECT_ID/global/urlMaps/l7-ilb-map"
}

Erstellen Sie die Firewallregel durch Senden einer POST-Anfrage an die Methode forwardingRules.insert. Ersetzen Sie dabei PROJECT_ID durch Ihre Projekt-ID.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/forwardingRules

{
"name": "FWRULE_A",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"portRange": "80-80",
"target": "projects/PROJECT_ID/global/targetHttpProxies/l7-ilb-proxy",
"loadBalancingScheme": "INTERNAL_MANAGED",
"subnetwork": "projects/PROJECT_ID/regions/REGION_A/subnetworks/SUBNET_A",
"network": "projects/PROJECT_ID/global/networks/NETWORK",
"networkTier": "PREMIUM"
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/forwardingRules

{
"name": "gil7forwarding-rule-b",
"IPAddress": "10.1.3.99",
"IPProtocol": "TCP",
"portRange": "80-80",
"target": "projects/PROJECT_ID/global/targetHttpProxies/l7-ilb-proxy",
"loadBalancingScheme": "INTERNAL_MANAGED",
"subnetwork": "projects/PROJECT_ID/regions/REGION_B/subnetworks/SUBNET_B",
"network": "projects/PROJECT_ID/global/networks/NETWORK",
"networkTier": "PREMIUM"
}

Bei HTTPS:

Lesen Sie die Zertifikat- und privaten Schlüsseldateien und erstellen Sie dann das SSL-Zertifikat. Im folgenden Beispiel wird gezeigt, wie das mit Python funktioniert.

from pathlib import Path
from pprint import pprint
from typing import Union

from googleapiclient import discovery


def create_regional_certificate(
    project_id: str,
    region: str,
    certificate_file: Union[str, Path],
    private_key_file: Union[str, Path],
    certificate_name: str,
    description: str = "Certificate created from a code sample.",
) -> dict:
    """
    Create a regional SSL self-signed certificate within your Google Cloud project.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        region: name of the region you want to use.
        certificate_file: path to the file with the certificate you want to create in your project.
        private_key_file: path to the private key you used to sign the certificate with.
        certificate_name: name for the certificate once it's created in your project.
        description: description of the certificate.

        Returns:
        Dictionary with information about the new regional SSL self-signed certificate.
    """
    service = discovery.build("compute", "v1")

    # Read the cert into memory
    with open(certificate_file) as f:
        _temp_cert = f.read()

    # Read the private_key into memory
    with open(private_key_file) as f:
        _temp_key = f.read()

    # Now that the certificate and private key are in memory, you can create the
    # certificate resource
    ssl_certificate_body = {
        "name": certificate_name,
        "description": description,
        "certificate": _temp_cert,
        "privateKey": _temp_key,
    }
    request = service.regionSslCertificates().insert(
        project=project_id, region=region, body=ssl_certificate_body
    )
    response = request.execute()
    pprint(response)

    return response

Erstellen Sie den Ziel-HTTPS-Proxy durch Senden einer POST-Anfrage an die Methode targetHttpsProxies.insert. Ersetzen Sie dabei PROJECT_ID durch Ihre Projekt-ID.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/targetHttpsProxy

{
"name": "l7-ilb-proxy",
"urlMap": "projects/PROJECT_ID/global/urlMaps/l7-ilb-map",
"sslCertificates": /projects/PROJECT_ID/global/sslCertificates/SSL_CERT_NAME
}

Erstellen Sie die Firewallregel durch Senden einer POST-Anfrage an die Methode globalForwardingRules.insert. Ersetzen Sie dabei PROJECT_ID durch Ihre Projekt-ID.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/forwardingRules

{
"name": "FWRULE_A",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"portRange": "80-80",
"target": "projects/PROJECT_ID/global/targetHttpsProxies/l7-ilb-proxy",
"loadBalancingScheme": "INTERNAL_MANAGED",
"subnetwork": "projects/PROJECT_ID/regions/REGION_A/subnetworks/SUBNET_A",
"network": "projects/PROJECT_ID/global/networks/NETWORK",
"networkTier": "PREMIUM"
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/forwardingRules

{
"name": "FWRULE_B",
"IPAddress": "10.1.3.99",
"IPProtocol": "TCP",
"portRange": "80-80",
"target": "projects/PROJECT_ID/global/targetHttpsProxies/l7-ilb-proxy",
"loadBalancingScheme": "INTERNAL_MANAGED",
"subnetwork": "projects/PROJECT_ID/regions/REGION_B/subnetworks/SUBNET_B",
"network": "projects/PROJECT_ID/global/networks/NETWORK",
"networkTier": "PREMIUM"
}

Load-Balancer testen

VM-Instanz zum Testen der Konnektivität erstellen

  1. Erstellen Sie eine Client-VM:

    gcloud compute instances create l7-ilb-client-a \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --network=NETWORK \
    --subnet=SUBNET_A \
    --zone=ZONE_A \
    --tags=allow-ssh

    gcloud compute instances create l7-ilb-client-b \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --network=NETWORK \
    --subnet=SUBNET_B \
    --zone=ZONE_B \
    --tags=allow-ssh

  2. Verwenden Sie SSH, um eine Verbindung zu jeder Clientinstanz herzustellen.

    gcloud compute ssh l7-ilb-client-a --zone=ZONE_A

    gcloud compute ssh l7-ilb-client-b --zone=ZONE_B

  3. Prüfen Sie, ob die IP-Adresse ihren Hostnamen bereitstellt.

    • Prüfen Sie, ob die Client-VM beide IP-Adressen erreichen kann. Der Befehl gibt den Namen der Backend-VM zurück, die die Anfrage verarbeitet hat:

      curl 10.1.2.99

      curl 10.1.3.99

      Ersetzen Sie für HTTPS-Tests curl durch die folgende Befehlszeile:

      curl -k 'https://test.example.com:443' --connect-to test.example.com:443:10.1.2.99:443

      curl -k 'https://test.example.com:443' --connect-to test.example.com:443:10.1.3.99:443

      Das Flag -k bewirkt, dass curl die Zertifikatsvalidierung überspringt.

    • Optional: Verwenden Sie den konfigurierten DNS-Eintrag, um die IP-Adresse aufzulösen, die der Client-VM am nächsten ist. DNS_NAME kann beispielsweise service.example.com sein.

      curl DNS_NAME

100 Anfragen ausführen und prüfen, ob ein Load-Balancing stattfindet

Bei HTTP:

  {
    RESULTS=
    for i in {1..100}
    do
        RESULTS="$RESULTS:$(curl --silent 10.1.2.99)"
    done
    echo ""
    echo " Results of load-balancing to 10.1.2.99: "
    echo "***"
    echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
    echo
  }
  

  {
    RESULTS=
    for i in {1..100}
    do
      RESULTS="$RESULTS:$(curl --silent 10.1.3.99)"
    done
    echo ""
    echo " Results of load-balancing to 10.1.3.99: "
    echo "***"
    echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
    echo
  }

Bei HTTPS:

  {
    RESULTS=
    for i in {1..100}
    do
      RESULTS="$RESULTS:$(curl -k -s 'https://test.example.com:443' --connect-to test.example.com:443:10.1.2.99:443)"
    done
    echo ""
    echo " Results of load-balancing to 10.1.2.99: "
    echo "***"
    echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
    echo
  }
  

  {
    RESULTS=
    for i in {1..100}
    do
       RESULTS="$RESULTS:$(curl -k -s 'https://test.example.com:443' --connect-to test.example.com:443:10.1.3.99:443)"
    done
    echo ""
    echo " Results of load-balancing to 10.1.3.99: "
    echo "***"
    echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
    echo
  }

Failover testen

  1. Prüfen Sie das Failover auf Backends in der Region REGION_A, wenn Backends in der REGION_B fehlerhaft oder nicht erreichbar sind. Entfernen Sie alle Backends aus REGION_B, um ein Failover zu simulieren:

    gcloud compute backend-services remove-backend BACKEND_SERVICE_NAME \
   --balancing-mode=UTILIZATION \
   --instance-group=gl7-ilb-mig-b \
   --instance-group-zone=ZONE_B

  2. Stellen Sie eine SSH-Verbindung zu einer Client-VM in REGION_B her.

    gcloud compute ssh l7-ilb-client-b \
   --zone=ZONE_B

  3. Senden Sie Anfragen an die IP-Adresse mit Load-Balancing in der Region REGION_B. Die Befehlsausgabe zeigt Antworten von Backend-VMs in REGION_A:

    {
RESULTS=
for i in {1..100}
do
  RESULTS="$RESULTS:$(curl -k -s 'https://test.example.com:443' --connect-to test.example.com:443:10.1.3.99:443)"
done
echo "***"
echo "*** Results of load-balancing to 10.1.3.99: "
echo "***"
echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
echo
}

Zusätzliche Konfigurationsoptionen

In diesem Abschnitt wird die Konfiguration des Beispiels um alternative und zusätzliche Optionen erweitert. Alle Aufgaben sind optional. Sie können sie in beliebiger Reihenfolge ausführen.

Sitzungsaffinität aktivieren

Diese Verfahren zeigen, wie Sie einen Backend-Dienst für den regionalen internen Application Load Balancer oder den regionenübergreifenden internen Application Load Balancer (Vorschau) aktualisieren, damit der Backend-Dienst verwendet die generierte Cookie-Affinität, Header-Feld-Affinität oder HTTP-Cookie-Affinität.

Wenn die generierte Cookie-Affinität aktiviert ist, gibt der Load-Balancer bei der ersten Anfrage ein Cookie aus. Bei jeder nachfolgenden Anfrage mit demselben Cookie leitet der Load-Balancer die Anfrage an dieselbe Backend-VM-Instanz oder denselben Backend-Endpunkt weiter. In diesem Beispiel heißt das Cookie GCILB.

Wenn die Header-Feld-Affinität aktiviert ist, leitet der Load-Balancer Anfragen an Backend-VMs oder Endpunkte in einer Netzwerk-Endpunktgruppe (NEG) anhand des Werts des mit dem Flag --custom-request-header angegebenen HTTP-Headers weiter. Die Header-Feld-Affinität ist nur gültig, wenn die Load-Balancing-Lokalitätsrichtlinie entweder RING_HASH oder MAGLEV ist und der konsistente Hash des Backend-Dienstes den Namen des HTTP-Headers angibt.

Wenn die HTTP-Cookie-Affinität aktiviert ist, leitet der Load-Balancer Anfragen an Back-End-VMs oder Endpunkte in einer NEG anhand eines HTTP-Cookies weiter, das im Flag HTTP_COOKIE mit dem optionalen Flag --affinity-cookie-ttl angegeben wird. Wenn der Client das Cookie in seiner HTTP-Anfrage nicht bereitstellt, generiert der Proxy das Cookie und gibt es in einem Set-Cookie-Header an den Client zurück. Die HTTP-Cookie-Affinität ist nur gültig, wenn die Load-Balancing-Lokalitätsrichtlinie entweder RING_HASH oder MAGLEV ist und der konsistente Hash des Backend-Dienstes das HTTP-Cookie angibt.

Console

So aktivieren oder ändern Sie die Sitzungsaffinität für einen Backend-Dienst:

  1. Rufen Sie in der Google Cloud Console die Seite Load-Balancing auf.

    Load-Balancing aufrufen

  2. Klicken Sie auf Back-Ends.
  3. Klicken Sie auf gil7-backend-service, den Namen des Backend-Dienstes, den Sie für dieses Beispiel erstellt haben, und dann auf Bearbeiten.
  4. Klicken Sie auf der Seite Backend-Dienstdetails auf Erweiterte Konfiguration.
  5. Wählen Sie unter Sitzungsaffinität die gewünschte Art der Sitzungsaffinität aus.
  6. Klicken Sie auf Aktualisieren.

gcloud

Mit den folgenden Befehlen der Google Cloud CLI können Sie den Backend-Dienst auf verschiedene Arten der Sitzungsaffinität aktualisieren:

    gcloud compute backend-services update gil7-backend-service \
        --session-affinity=[GENERATED_COOKIE | HEADER_FIELD | HTTP_COOKIE | CLIENT_IP] \
        --global

API

Zum Festlegen der Sitzungsaffinität senden Sie eine -Anfrage an die Methode backendServices/patch.

    PATCH https://compute.googleapis.com/compute/v1/projects/[PROJECT_ID]/global/backendServices/gil7-backend-service
    {
    "sessionAffinity": ["GENERATED_COOKIE" | "HEADER_FIELD" | "HTTP_COOKIE" | "CLIENT_IP" ]
    }

Einschränken, welche Clients Traffic an den Load-Balancer senden können

Sie können verhindern, dass Clients eine Verbindung zu einer Weiterleitungsregel-VIP des internen Application Load Balancers herstellen, indem Sie für diese Clients Firewallregeln für ausgehenden Traffic konfigurieren. Legen Sie diese Firewallregeln für bestimmte Client-VMs fest, basierend auf Dienstkonten oder Tags.

Mit Firewallregeln können Sie den eingehenden Traffic nicht auf bestimmte Weiterleitungsregel-VIPs des internen Application Load Balancers beschränken. Jeder Client im selben VPC-Netzwerk und in derselben Region wie die Weiterleitungsregel-VIP kann generell Traffic an die Weiterleitungsregel-VIP senden.

Außerdem stammen alle Anfragen an Back-Ends von Proxys, die IP-Adressen im Bereich des Nur-Proxy-Subnetzes verwenden. Es ist nicht möglich, Firewallregeln zu erstellen, die eingehenden Traffic zu diesen Back-Ends anhand der von einem Client verwendeten Weiterleitungsregel-VIP zulassen oder ablehnen.

Die folgenden Beispiele zeigen, wie Sie Firewallregeln für ausgehenden Traffic verwenden können, um den Traffic zur Weiterleitungsregel-VIP des Load-Balancers zu beschränken.

Console

Zum Identifizieren der Client-VMs taggen Sie die spezifischen VMs, die Sie einschränken möchten. Mit diesen Tags werden Firewallregeln mit den getaggten Client-VMs verknüpft. Fügen Sie das Tag in diesen Schritten dem Feld TARGET_TAG hinzu.

Verwenden Sie dazu eine einzelne Firewallregel oder mehrere Regeln.

Einzelne Firewallregel für ausgehenden Traffic

Sie können eine Firewallregel für ausgehenden Traffic so konfigurieren, dass der gesamte ausgehende Traffic von getaggten Client-VMs an die VIP eines Load-Balancers abgelehnt wird.

  1. Rufen Sie in der Google Cloud Console die Seite Firewallregeln auf.

    Zu Firewallregeln

  2. Klicken Sie auf Firewallregel erstellen, um die Regel zu erstellen, durch die ausgehender Traffic von getaggten Client-VMs an die VIP eines Load-Balancers abgelehnt wird.

    • Name: fr-deny-access
    • Netzwerk: lb-network
    • Priorität: 100
    • Trafficrichtung: Ausgehend
    • Aktion bei Übereinstimmung: Ablehnen
    • Ziele: Specified target tags
    • Zieltags: TARGET_TAG
    • Zielfilter: IP-Bereiche
    • Ziel-IP-Bereiche: 10.1.2.99
    • Protokolle und Ports:
      • Wählen Sie Angegebene Protokolle und Ports aus.
      • Klicken Sie das Kästchen tcp an und geben Sie 80 als Portnummer ein.

  3. Klicken Sie auf Erstellen.

Mehrere Firewallregeln für ausgehenden Traffic

Ein skalierbareres Vorgehen besteht darin, zwei Regeln festzulegen. Eine Standardregel mit niedriger Priorität, die verhindert, dass Clients auf die VIP des Load-Balancers zugreifen. Eine zweite Regel mit höherer Priorität, dank der eine Teilmenge von getaggten Clients auf die VIP des Load-Balancers zugreifen kann. Nur getaggte VMs können auf die VIP zugreifen.

  1. Rufen Sie in der Google Cloud Console die Seite Firewallregeln auf.

    Zu Firewallregeln

  2. Klicken Sie auf Firewallregel erstellen, um die Regel mit niedrigerer Priorität zu erstellen und den Zugriff standardmäßig abzulehnen:

    • Name: fr-deny-all-access-low-priority
    • Netzwerk: lb-network
    • Priorität: 200
    • Trafficrichtung: Ausgehend
    • Aktion bei Übereinstimmung: Ablehnen
    • Ziele: Specified target tags
    • Zieltags: TARGET_TAG
    • Zielfilter: IP-Bereiche
    • Ziel-IP-Bereiche: 10.1.2.99
    • Protokolle und Ports:
      • Wählen Sie Angegebene Protokolle und Ports aus.
      • Klicken Sie das Kästchen TCP an und geben Sie 80 als Portnummer ein.

  3. Klicken Sie auf Erstellen.

  4. Klicken Sie auf Firewallregel erstellen, um die Regel mit höherer Priorität zu erstellen, um Traffic von bestimmten getaggten Instanzen zuzulassen.

    • Name: fr-allow-some-access-high-priority
    • Netzwerk: lb-network
    • Priorität: 100
    • Trafficrichtung: Ausgehend
    • Aktion bei Übereinstimmung: Zulassen
    • Ziele: Angegebene Ziel-Tags
    • Zieltags: TARGET_TAG
    • Zielfilter: IP-Bereiche
    • Ziel-IP-Bereiche: 10.1.2.99
    • Protokolle und Ports:
      • Wählen Sie Angegebene Protokolle und Ports aus.
      • Klicken Sie das Kästchen TCP an und geben Sie 80 als Portnummer ein.

  5. Klicken Sie auf Erstellen.

gcloud

Zum Identifizieren der Client-VMs taggen Sie die spezifischen VMs, die Sie einschränken möchten. Fügen Sie das Tag in diesen Schritten dem Feld TARGET_TAG hinzu.

Verwenden Sie dazu eine einzelne Firewallregel oder mehrere Regeln.

Einzelne Firewallregel für ausgehenden Traffic

Sie können eine Firewallregel für ausgehenden Traffic so konfigurieren, dass der gesamte ausgehende Traffic von getaggten Client-VMs an die VIP eines Load-Balancers abgelehnt wird.

gcloud compute firewall-rules create fr-deny-access \
  --network=lb-network \
  --action=deny \
  --direction=egress \
  --rules=tcp \
  --priority=100 \
  --destination-ranges=10.1.2.99 \
  --target-tags=TARGET_TAG

Mehrere Firewallregeln für ausgehenden Traffic

Ein skalierbareres Vorgehen besteht darin, zwei Regeln festzulegen: eine Standardregel mit niedriger Priorität, die verhindert, dass alle Clients auf die VIP des Load-Balancers zugreifen, und eine zweite Regel mit höherer Priorität, über die eine Teilmenge von getaggten Clients auf den VIP des Load-Balancers zugreifen kann. Nur getaggte VMs können auf die VIP zugreifen.

  1. Erstellen Sie die Regel mit niedrigerer Priorität:

    gcloud compute firewall-rules create fr-deny-all-access-low-priority \
  --network=lb-network \
  --action=deny \
  --direction=egress \
  --rules=tcp \
  --priority=200 \
  --destination-ranges=10.1.2.99

  2. Erstellen Sie die Regel mit höherer Priorität:

    gcloud compute firewall-rules create fr-allow-some-access-high-priority \
  --network=lb-network \
  --action=allow \
  --direction=egress \
  --rules=tcp \
  --priority=100 \
  --destination-ranges=10.1.2.99 \
  --target-tags=TARGET_TAG

Wenn Sie den Zugriff über Dienstkonten steuern möchten, verwenden Sie beim Erstellen von Firewallregeln das Flag --target-service-accounts-Option anstelle des Flags --target-tags.

Eingeschränkten Zugriff auf Back-Ends des internen Application Load Balancers basierend auf Subnetzen skalieren

Es ist nicht ratsam, separate Firewallregeln zu verwalten oder neue IP-Adressen mit Load-Balancing zu bestehenden Regeln hinzuzufügen, wie im vorherigen Abschnitt beschrieben, wenn die Anzahl der Weiterleitungsregeln zunimmt. Sie können dies verhindern, indem Sie IP-Adressen von Weiterleitungsregeln aus einem reservierten Subnetz zuweisen. Anschließend kann der Traffic von getaggten Instanzen oder Dienstkonten zugelassen oder blockiert werden. Dazu wird das reservierte Subnetz als Zielbereich für Firewallregeln verwendet. Auf diese Weise können Sie den Zugriff auf eine Gruppe von Weiterleitungsregel-VIPs effektiv steuern, ohne VIP-spezifische Firewallregeln für ausgehenden Traffic verwenden zu müssen.

Im Folgenden werden die grundlegenden Schritte beschrieben, mit denen Sie separat alle anderen erforderlichen Load-Balancer-Ressourcen erstellen.

gcloud

  1. Erstellen Sie ein regionales Subnetz, das für die Zuordnung von IP-Adressen mit Load-Balancing für Weiterleitungsregeln verwendet wird:

    gcloud compute networks subnets create l7-ilb-restricted-subnet \
  --network=lb-network \
  --region=us-west1 \
  --range=10.127.0.0/24

  2. Erstellen Sie eine Weiterleitungsregel, die eine Adresse aus dem Subnetz verwendet. Im folgenden Beispiel wird die Adresse 10.127.0.1 aus dem Subnetz verwendet, das im vorherigen Schritt erstellt wurde. 

    gcloud compute forwarding-rules create l7-ilb-forwarding-rule-restricted \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=lb-network \
  --subnet=l7-ilb-restricted-subnet \
  --address=10.127.0.1 \
  --ports=80 \
  --global \
  --target-http-proxy=gil7-http-proxy

  3. Erstellen Sie eine Firewallregel, um den Traffic für die Bereichs-IP-Adressen im Subnetz der Weiterleitungsregel (l7-ilb-restricted-subnet) zu beschränken:

    gcloud compute firewall-rules create restrict-traffic-to-subnet \
  --network=lb-network \
  --action=deny \
  --direction=egress \
  --rules=tcp:80 \
  --priority=100 \
  --destination-ranges=10.127.0.0/24 \
  --target-tags=TARGET_TAG

Dieselbe IP-Adresse für mehrere interne Weiterleitungsregeln verwenden

Damit mehrere interne Weiterleitungsregeln dieselbe interne IP-Adresse haben, müssen Sie die IP-Adresse reservieren und das Flag --purpose auf SHARED_LOADBALANCER_VIP setzen.

gcloud 

gcloud compute addresses create SHARED_IP_ADDRESS_NAME \
    --region=REGION \
    --subnet=SUBNET_NAME \
    --purpose=SHARED_LOADBALANCER_VIP
Wenn Sie HTTP-Traffic an HTTPS weiterleiten müssen, können Sie zwei Weiterleitungsregeln erstellen, die eine gemeinsame IP-Adresse nutzen. Weitere Informationen finden Sie unter HTTP-zu-HTTPS-Weiterleitung für interne Application Load Balancer einrichten.

DNS-Routingrichtlinien konfigurieren

Wenn sich Ihre Clients in mehreren Regionen befinden, möchten Sie möglicherweise den regionenübergreifenden internen Application Load Balancer mithilfe von VIPs in diesen Regionen zugänglich machen. In dieser multiregionalen Einrichtung werden die Latenz und die Kosten für den Netzwerktransport minimiert. Darüber hinaus können Sie eine DNS-basierte globale Load-Balancing-Lösung einrichten, die gegen regionale Ausfälle sicher ist. Weitere Informationen finden Sie unter DNS-Routingrichtlinien und Systemdiagnosen verwalten.

gcloud

Zum Erstellen eines DNS-Eintrags mit einer 30-Sekunden-TTL verwenden Sie den Befehl gcloud dns record-sets create.

gcloud dns record-sets create DNS_ENTRY --ttl="30" \
  --type="A" --zone="service-zone" \
  --routing-policy-type="GEO" \
  --routing-policy-data="REGION_A=gil7-forwarding-rule-a@global;REGION_B=gil7-forwarding-rule-b@global" \
  --enable-health-checking

Ersetzen Sie Folgendes:

  • DNS_ENTRY: DNS- oder Domainname des Datensatzes

    Beispiel: service.example.com

  • REGION_A und REGION_B: die Regionen, in denen Sie den Load-Balancer konfiguriert haben

API

Erstellen Sie den DNS-Eintrag durch eine POST-Anfrage an die Methode ResourceRecordSets.create. Ersetzen Sie dabei PROJECT_ID durch Ihre Projekt-ID.

POST https://www.googleapis.com/dns/v1/projects/PROJECT_ID/managedZones/SERVICE_ZONE/rrsets
{
  "name": "DNS_ENTRY",
  "type": "A",
  "ttl": 30,
  "routingPolicy": {
    "geo": {
      "items": [
        {
          "location": "REGION_A",
          "healthCheckedTargets": {
            "internalLoadBalancers": [
              {
                "loadBalancerType": "globalL7ilb",
                "ipAddress": "IP_ADDRESS",
                "port": "80",
                "ipProtocol": "tcp",
                "networkUrl": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
                "project": "PROJECT_ID"
              }
            ]
          }
        },
        {
          "location": "REGION_B",
          "healthCheckedTargets": {
            "internalLoadBalancers": [
              {
                "loadBalancerType": "globalL7ilb",
                "ipAddress": "IP_ADDRESS_B",
                "port": "80",
                "ipProtocol": "tcp",
                "networkUrl": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
                "project": "PROJECT_ID"
              }
            ]
          }
        }
      ]
    }
  }
}

HTTP-Keepalive-Zeitlimit des Clients aktualisieren

Der in den vorherigen Schritten erstellte Load Balancer wurde mit einem Standardwert für das Client-HTTP-Keepalive-Zeitlimit konfiguriert.

Folgen Sie der nachstehenden Anleitung, um das HTTP-Keepalive-Zeitlimit des Clients zu aktualisieren.

Console

  1. Rufen Sie in der Google Cloud Console die Seite Load-Balancing auf.

    Load-Balancing aufrufen.

  2. Klicken Sie auf den Namen des Load-Balancers, den Sie ändern möchten.
  3. Klicken Sie auf Bearbeiten.
  4. Klicken Sie auf Frontend-Konfiguration.
  5. Maximieren Sie Erweiterte Funktionen. Geben Sie für HTTP-Keepalive-Zeitlimit ein Zeitlimit ein.
  6. Klicken Sie auf Aktualisieren.
  7. Klicken Sie zum Prüfen Ihrer Änderungen auf Prüfen und abschließen und dann auf Aktualisieren.

gcloud

Aktualisieren Sie bei einem HTTP-Load-Balancer den Ziel-HTTP-Proxy mit dem Befehl gcloud compute target-http-proxies update:

    gcloud compute target-http-proxies update TARGET_HTTP_PROXY_NAME \
        --http-keep-alive-timeout-sec=HTTP_KEEP_ALIVE_TIMEOUT_SEC \
        --global

Aktualisieren Sie bei einem HTTPS-Load-Balancer den Ziel-HTTPS-Proxy mit dem Befehl gcloud compute target-https-proxies update:

    gcloud compute target-https-proxies update TARGET_HTTPS_PROXY_NAME \
        --http-keep-alive-timeout-sec=HTTP_KEEP_ALIVE_TIMEOUT_SEC \
        --global

Ersetzen Sie Folgendes:

  • TARGET_HTTP_PROXY_NAME ist der Name des HTTP-Ziel-Proxys.
  • TARGET_HTTPS_PROXY_NAME ist der Name des HTTPS-Ziel-Proxys.
  • HTTP_KEEP_ALIVE_TIMEOUT_SEC ist das HTTP-Keepalive-Zeitlimit von 5 bis 600 Sekunden.

Ausreißererkennung aktivieren

Sie können die Ausreißererkennung für globale Backend-Dienste aktivieren, um fehlerhafte serverlose NEGs zu identifizieren und die Anzahl der Anfragen zu reduzieren, die an die fehlerhaften serverlosen NEGs gesendet werden.

Die Ausreißererkennung wird für den Backend-Dienst mithilfe einer der folgenden Methoden aktiviert:

  • Die Methode consecutiveErrors (outlierDetection.consecutiveErrors), bei der ein HTTP-Statuscode der 5xx-Serie als Fehler gilt.
  • Die Methode consecutiveGatewayFailure (outlierDetection.consecutiveGatewayFailure), bei der nur die HTTP-Statuscodes 502, 503 und 504 als Fehler gelten.

Führen Sie die folgenden Schritte aus, um die Ausreißererkennung für einen vorhandenen Backend-Dienst zu aktivieren. Beachten Sie, dass auch nach der Aktivierung der Ausreißererkennung einige Anfragen an den fehlerhaften Dienst gesendet werden können und einen 5xx-Statuscode an die Clients zurückgeben. Zur weiteren Reduzierung der Fehlerrate können Sie aggressivere Werte für die Ausreißererkennungsparameter konfigurieren. Weitere Informationen finden Sie im Feld outlierDetection.

Console

  1. Rufen Sie in der Google Cloud Console die Seite Load-Balancing auf.

    Load-Balancing aufrufen

  2. Klicken Sie auf den Namen des Load-Balancers, dessen Backend-Dienst Sie bearbeiten möchten.

  3. Klicken Sie auf der Seite Details zum Load-Balancer auf Bearbeiten.

  4. Klicken Sie auf der Seite Regionenübergreifenden internen Application Load Balancer bearbeiten auf Backend-Konfiguration.

  5. Klicken Sie auf der Seite Backend-Konfiguration für den Backend-Dienst, den Sie ändern möchten, auf Bearbeiten.

  6. Scrollen Sie nach unten und maximieren Sie den Abschnitt Erweiterte Konfigurationen.

  7. Wählen Sie im Abschnitt Ausreißererkennung das Kästchen Aktivieren aus.

  8. Klicken Sie auf Bearbeiten, um die Ausreißererkennung zu konfigurieren.

    Prüfen Sie, ob die folgenden Optionen mit diesen Werten konfiguriert sind:

    Attribut Wert
    Aufeinanderfolgende Fehler 5
    Intervall 1000
    Basisausschlusszeit 30.000
    Maximale Prozentzahl an Ausschlüssen 50
    Aufeinanderfolgende Fehler werden erzwungen 100

    In diesem Beispiel wird die Ausreißererkennungsanalyse jede Sekunde ausgeführt. Wenn die Anzahl der aufeinanderfolgenden HTTP-Statuscodes 5xx, die von einem Envoy-Proxy empfangen werden, mindestens fünf ist, wird der Backend-Endpunkt für 30 Sekunden aus dem Load-Balancing-Pool dieses Envoy-Proxys ausgeschlossen. Wenn der Erzwingungsprozentsatz auf 100 % eingestellt ist, erzwingt der Backend-Dienst den Ausschluss fehlerhafter Endpunkte aus den Load-Balancing-Pools dieser spezifischen Envoy-Proxys jedes Mal, wenn die Ausreißererkennungsanalyse läuft. Wenn die Ausschlussbedingungen erfüllt sind, können bis zu 50 % der Backend-Endpunkte aus dem Load-Balancing-Pool ausgeschlossen werden.

  9. Klicken Sie auf Speichern.

  10. Klicken Sie zum Aktualisieren des Backend-Dienstes auf Aktualisieren.

  11. Klicken Sie zum Aktualisieren des Load Balancers auf der Seite Regionenübergreifenden internen Application Load Balancer bearbeiten auf Aktualisieren.

gcloud

  1. Exportieren Sie den Backend-Dienst in eine YAML-Datei.

    gcloud compute backend-services export BACKEND_SERVICE_NAME \
  --destination=BACKEND_SERVICE_NAME.yaml --global

    Ersetzen Sie BACKEND_SERVICE_NAME durch den Namen des Backend-Dienstes.

  2. Bearbeiten Sie die YAML-Konfiguration des Backend-Dienstes, um die Felder für die Ausreißererkennung hinzuzufügen, wie in der folgenden YAML-Konfiguration im Abschnitt outlierDetection hervorgehoben.

    In diesem Beispiel wird die Ausreißererkennungsanalyse jede Sekunde ausgeführt. Wenn die Anzahl der aufeinanderfolgenden HTTP-Statuscodes 5xx, die von einem Envoy-Proxy empfangen werden, mindestens fünf ist, wird der Backend-Endpunkt für 30 Sekunden aus dem Load-Balancing-Pool dieses Envoy-Proxys ausgeschlossen. Wenn der Erzwingungsprozentsatz auf 100 % eingestellt ist, erzwingt der Backend-Dienst den Ausschluss fehlerhafter Endpunkte aus den Load-Balancing-Pools dieser spezifischen Envoy-Proxys jedes Mal, wenn die Ausreißererkennungsanalyse läuft. Wenn die Ausschlussbedingungen erfüllt sind, können bis zu 50 % der Backend-Endpunkte aus dem Load-Balancing-Pool ausgeschlossen werden. 

    name: BACKEND_SERVICE_NAME
backends:
- balancingMode: UTILIZATION
  capacityScaler: 1.0
  group: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_A/networkEndpointGroups/SERVERLESS_NEG_NAME
- balancingMode: UTILIZATION
  capacityScaler: 1.0
  group: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_B/networkEndpointGroups/SERVERLESS_NEG_NAME_2
outlierDetection:
  baseEjectionTime:
    nanos: 0
    seconds: 30
  consecutiveErrors: 5
  enforcingConsecutiveErrors: 100
  interval:
    nanos: 0
    seconds: 1
  maxEjectionPercent: 50
port: 80
selfLink: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_NAME
sessionAffinity: NONE
timeoutSec: 30
...

    Ersetzen Sie Folgendes:

    • BACKEND_SERVICE_NAME: der Name des Backend-Dienstes
    • PROJECT_ID: die Projekt-ID
    • REGION_A und REGION_B: die Regionen, in denen der Load-Balancer konfiguriert wurde.
    • SERVERLESS_NEG_NAME: der Name der ersten serverlosen NEG
    • SERVERLESS_NEG_NAME_2: der Name der zweiten serverlosen NEG

  3. Aktualisieren Sie den Backend-Dienst. Importieren Sie dazu die neueste Konfiguration.

    gcloud compute backend-services import BACKEND_SERVICE_NAME \
  --source=BACKEND_SERVICE_NAME.yaml --global

    Die Ausreißererkennung ist jetzt für den Backend-Dienst aktiviert.

Nächste Schritte