Regionenübergreifenden internen Proxy-Network Load Balancer mit VM-Instanzgruppen-Back-Ends einrichten

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

Hinweise

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

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:

Regionenübergreifender interner Proxy-Network Load Balancer
Hochverfügbarkeitsbereitstellung für interne Proxy-Network 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 Proxy-Network Load Balancer verwenden, Nur-Proxy-Subnetze erstellen. Das Nur-Proxy-Subnetz der Region wird von allen regionenübergreifenden internen Proxy-Network 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_B den primären IP-Adressbereich 10.129.0.0/23 und für REGION_A 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-Back-Ends 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. Ein globaler Ziel-TCP-Proxy, der eine Anfrage vom Nutzer empfängt und an den Backend-Dienst weiterleitet.

  5. Globale Weiterleitungsregeln, die die regionale interne IP-Adresse Ihres Load Balancers haben und jede eingehende Anfrage an den Zielproxy weiterleiten können.

    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.

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 über 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 gilt, für die ein Load Balancing durchgeführt wird, und die TCP-Traffic auf den Ports 80, 443 und 8080 von den verwalteten Proxys des internen Proxy-Network 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 Proxy-Network 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

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 Proxy-Network Load Balancer 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 gil4-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 gil4-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 gl4-ilb-miga 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 gil4-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 gl4-ilb-migb 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 gil4-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 gil4-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 gil4-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 gl4-ilb-miga \
    --zone=ZONE_A \
    --size=2 \
    --template=gil4-backendwest1-template

    gcloud compute instance-groups managed create gl4-ilb-migb \
    --zone=ZONE_B \
    --size=2 \
    --template=gil4-backendeast1-template

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":"gil4-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
       }
     ]
  }
}

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

{
  "name":"gil4-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": "gl4-ilb-miga",
  "zone": "projects/PROJECT_ID/zones/ZONE_A",
  "instanceTemplate": "projects/PROJECT_ID/global/instanceTemplates/gil4-backendwest1-template",
  "baseInstanceName": "gl4-ilb-miga",
  "targetSize": 2
}

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

{
  "name": "gl4-ilb-migb",
  "zone": "projects/PROJECT_ID/zones/ZONE_A",
  "instanceTemplate": "projects/PROJECT_ID/global/instanceTemplates/gil4-backendwest1-template",
  "baseInstanceName": "gl4-ilb-migb",
  "targetSize": 2
}

Load-Balancer konfigurieren

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

  • Eine globale TCP-Systemdiagnose.
  • Einen globalen Back-End-Dienst mit denselben MIGs wie das Back-End.
  • 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.

Proxyverfügbarkeit

Manchmal haben Google Cloud-Regionen nicht genügend Proxykapazität für einen neuen Load-Balancer. In diesem Fall gibt die Google Cloud Console beim Erstellen des Load-Balancers eine Warnmeldung zur Proxyverfügbarkeit aus. Sie haben folgende Möglichkeiten, dieses Problem zu beheben:

  • Wählen Sie eine andere Region für den Load-Balancer aus. Diese Option kann sinnvoll sein, wenn Sie Back-Ends in einer anderen Region haben.
  • Wählen Sie ein VPC-Netzwerk aus, dem bereits ein Nur-Proxy-Subnetz zugewiesen ist.

  • Warten Sie, bis das Kapazitätsproblem behoben ist.

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 Network Load Balancer (TCP/UDP/SSL) aus und klicken Sie auf Weiter.
  4. Wählen Sie unter Proxy oder Passthrough die Option Proxy-Load Balancer aus und klicken Sie auf Weiter.
  5. Wählen Sie für Öffentlich oder intern die Option Intern aus und klicken Sie auf Weiter.
  6. Wählen Sie für Regionenübergreifende oder Einzelregions-Bereitstellung die Option Best für regionenübergreifende Arbeitslasten aus und klicken Sie auf Weiter.
  7. 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

  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.
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 Protocol die Option TCP 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.

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 tcp.

    gcloud compute health-checks create tcp global-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 gl4-gilb-backend-service \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --protocol=TCP \
  --enable-logging \
  --logging-sample-rate=1.0 \
  --health-checks=global-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 gl4-gilb-backend-service \
  --balancing-mode=CONNECTION \
  --max-connections=50 \
  --instance-group=gl4-ilb-miga \
  --instance-group-zone=ZONE_A \
  --global

    gcloud compute backend-services add-backend gl4-gilb-backend-service \
  --balancing-mode=CONNECTION \
  --max-connections=50 \
  --instance-group=gl4-ilb-migb \
  --instance-group-zone=ZONE_B \
  --global

  4. Erstellen Sie den Zielproxy.

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

    gcloud compute target-tcp-proxies create gilb-tcp-proxy \
  --backend-service=gl4-gilb-backend-service \
  --global

  5. Erstellen Sie zwei Weiterleitungsregeln, eine mit einer VIP (10.1.2.99) in REGION_B und eine weitere mit einer VIP (10.1.3.99) in 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.

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

    gcloud compute forwarding-rules create gil4forwarding-rule-a \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=NETWORK \
  --subnet=SUBNET_A \
  --subnet-region=REGION_A \
  --address=10.1.2.99 \
  --ports=80 \
  --target-tcp-proxy=gilb-tcp-proxy \
  --global

    gcloud compute forwarding-rules create gil4forwarding-rule-b \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=NETWORK \
  --subnet=SUBNET_B \
  --subnet-region=REGION_B \
  --address=10.1.3.99 \
  --ports=80 \
  --target-tcp-proxy=gilb-tcp-proxy \
  --global

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-health-check",
"type": "TCP",
"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": "gl4-gilb-backend-service",
"backends": [
  {
    "group": "projects/PROJECT_ID/zones/ZONE_A/instanceGroups/gl4-ilb-miga",
    "balancingMode": "CONNECTION"
  },
  {
    "group": "projects/PROJECT_ID/zones/ZONE_B/instanceGroups/gl4-ilb-migb",
    "balancingMode": "CONNECTION"
  }
],
"healthChecks": [
  "projects/PROJECT_ID/regions/global/healthChecks/global-health-check"
],
"loadBalancingScheme": "INTERNAL_MANAGED"
}

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

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

{
"name": "l4-ilb-proxy",
}

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": "gil4forwarding-rule-a",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"portRange": "80-80",
"target": "projects/PROJECT_ID/global/targetTcpProxies/l4-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": "gil4forwarding-rule-b",
"IPAddress": "10.1.3.99",
"IPProtocol": "TCP",
"portRange": "80-80",
"target": "projects/PROJECT_ID/global/targetTcpProxies/l4-ilb-proxy",
"loadBalancingScheme": "INTERNAL_MANAGED",
"subnetwork": "projects/PROJECT_ID/regions/REGION_B/subnetworks/SUBNET_B",
"network": "projects/PROJECT_ID/global/networks/NETWORK",
"networkTier": "PREMIUM"
}

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": "gil4forwarding-rule-a",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"portRange": "80-80",
"target": "projects/PROJECT_ID/global/targetTcpProxies/l4-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": "gil4forwarding-rule-b",
"IPAddress": "10.1.3.99",
"IPProtocol": "TCP",
"portRange": "80-80",
"target": "projects/PROJECT_ID/global/targetTcpProxies/l4-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. So erstellen Sie eine Client-VM in den Regionen REGION_B und REGION_A:

    gcloud compute instances create l4-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 l4-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 l4-ilb-client-a --zone=ZONE_A

    gcloud compute ssh l4-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 sollte erfolgreich sein und den Namen der Back-End-VM zurückgeben, von der die Anfrage verarbeitet wurde:

      curl 10.1.2.99

      curl 10.1.3.99

Failover testen

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

    gcloud compute backend-services remove-backend gl4-gilb-backend-service \
  --instance-group=gl4-ilb-migb \
  --instance-group-zone=ZONE_B \
  --global

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

    gcloud compute ssh l4-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.

PROXY-Protokoll für den Erhalt der Verbindungsinformationen des Clients

Der interne Proxy-Network Load Balancer beendet TCP-Verbindungen vom Client und erstellt neue Verbindungen zu den VM-Instanzen. Standardmäßig bleiben die ursprüngliche IP-Adresse des Clients und die Portinformationen nicht automatisch erhalten.

Aktivieren Sie deshalb das PROXY-Protokoll (Version 1). Damit bleiben die ursprünglichen Verbindungsinformationen erhalten und werden an Ihre Instanzen gesendet. Mit diesem Protokoll wird mit der Anfrage zusätzlich ein Header mit Quell-IP-Adresse, Ziel-IP-Adresse und Portnummern an die Instanz gesendet.

Achten Sie darauf, dass die Back-End-Instanzen des internen Proxy-Network Load Balancers HTTP- oder HTTPS-Server ausführen, die PROXY-Protokoll-Header unterstützen. Wenn die HTTP-Server nicht für die Unterstützung von PROXY-Protokoll-Headern konfiguriert sind, geben die Back-End-Instanzen leere Antworten zurück. Das PROXY-Protokoll funktioniert beispielsweise nicht mit der Apache HTTP Server-Software. Sie können verschiedene Webserver-Software wie Nginx verwenden.

Wenn Sie das PROXY-Protokoll für Nutzer-Traffic festlegen, müssen Sie es auch für die Systemdiagnosen festlegen. Wenn Sie Systemdiagnosen und Inhaltsbereitstellung über denselben Port durchführen, legen Sie den --proxy-header der Systemdiagnose so fest, dass er mit der Einstellung des Load-Balancers übereinstimmt.

Der PROXY-Protokoll-Header enthält in der Regel eine einzelne, für Nutzer lesbare Textzeile im folgenden Format:

PROXY TCP4 <client IP> <load balancing IP> <source port> <dest port>\r\n

Im Folgenden ist ein Beispiel für das PROXY-Protokoll dargestellt:

PROXY TCP4 192.0.2.1 198.51.100.1 15221 110\r\n

Im vorherigen Beispiel lautet die Client-IP-Adresse 192.0.2.1, die Load Balancing-IP-Adresse 198.51.100.1, der Clientport 15221 und der Zielport 110.

Ist die IP-Adresse des Clients nicht bekannt, erstellt der Load Balancer einen Proxy-Protokoll-Header in folgendem Format:

PROXY UNKNOWN\r\n

PROXY-Protokoll-Header für den Ziel-TCP-Proxy aktualisieren

In der Beispielkonfiguration für Load Balancer auf dieser Seite erfahren Sie, wie Sie den PROXY-Protokoll-Header beim Erstellen des internen Proxy-Network Load Balancers aktivieren. Führen Sie die folgenden Schritte aus, um den PROXY-Protokoll-Header eines bestehenden Ziel-TCP-Proxys zu ändern.

Console

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

    Load-Balancing aufrufen

  2. Klicken Sie neben dem Load Balancer auf Bearbeiten.

  3. Klicken Sie auf Front-End-Konfiguration.

  4. Ändern Sie den Wert des Felds Proxyprotokoll zu Ein.

  5. Klicken Sie auf Update (Aktualisieren), um die Änderungen zu speichern.

gcloud

Bearbeiten Sie im folgenden Befehl das Feld --proxy-header und legen Sie es je nach Anforderung auf NONE oder PROXY_V1 fest.

gcloud compute target-ssl-proxies update int-tcp-target-proxy \
    --proxy-header=[NONE | PROXY_V1]

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

Sitzungsaffinität aktivieren

Die Beispielkonfiguration erstellt einen Backend-Dienst ohne Sitzungsaffinität.

Diese Verfahren zeigen, wie Sie einen Backend-Dienst für den vorher erstellten Beispiel-Load Balancer aktualisieren, damit der Backend-Dienst die Client-IP-Affinität oder Cookie-Affinität verwendet.

Wenn die Client-IP-Affinität aktiviert ist, leitet der Load-Balancer die Anfragen eines bestimmten Clients anhand eines Hashs, der aus der IP-Adresse des Clients und der IP-Adresse des Load-Balancers (der internen IP-Adresse einer internen Weiterleitungsregel) erstellt wurde, an dieselbe Backend-VM weiter.

Console

So aktivieren Sie die Client-IP-Sitzungsaffinität:

  1. Rufen Sie in der Google Cloud Console die Seite Load-Balancing auf.
    Gehen Sie zu „Load-Balancing“
  2. Klicken Sie auf Back-Ends.
  3. Klicken Sie auf den Namen des Back-End-Dienstes, den Sie für dieses Beispiel erstellt haben, und dann auf Bearbeiten.
  4. Klicken Sie auf der Seite Back-End-Dienstdetails auf Erweiterte Konfiguration.
  5. Wählen Sie im Menü unter Sitzungsaffinität die Option Client-IP aus.
  6. Klicken Sie auf Aktualisieren.

gcloud

Aktualisieren Sie den Backend-Dienst BACKEND_SERVICE mit dem folgenden gcloud-Befehl. Geben Sie dabei die Sitzungsaffinität der Client-IP an:

gcloud compute backend-services update BACKEND_SERVICE \
    --global \
    --session-affinity=CLIENT_IP

Verbindungsausgleich aktivieren

Sie können für Backend-Dienste den Verbindungsausgleich aktivieren, um Dienstausfälle für Nutzer zu minimieren, wenn eine Instanz, die Traffic bereitstellt, beendet bzw. manuell oder durch Autoscaling entfernt wird. Weitere Informationen zum Verbindungsausgleich finden Sie unter Verbindungsausgleich aktivieren.

Nächste Schritte