Regionalen externen Application Load Balancer mit VM-Instanzgruppen-Back-Ends einrichten

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

Da Sie mit regionalen externen Application Load Balancern in bestimmten Regionen Load Balancer erstellen können, werden sie häufig für Arbeitslasten verwendet, für die gesetzliche Compliance-Anforderungen gelten. Arbeitslasten, die Zugriff auf ausgehenden Traffic der Standard-Netzwerkstufe benötigen, sind ein weiterer häufiger Anwendungsfall für regionale externe Application Load Balancer, da die regionalen externen Application Load Balancer die Standard-Netzwerkdienststufe unterstützen.

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

• Übersicht über externen Application Load Balancer
• Übersicht über VPC-Firewallregeln

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	Netzwerkadministrator
Firewallregeln hinzufügen und löschen	Sicherheitsadministrator
Instanzen erstellen	Instanzadministrator

Weitere Informationen finden Sie in folgenden Leitfäden:

• Zugriffssteuerung
• IAM-Bedingungen

Einrichtung: Übersicht

Sie können einen regionalen externen Application Load Balancer konfigurieren, wie im folgenden allgemeinen Konfigurationsablauf beschrieben. Die nummerierten Schritte beziehen sich auf die Zahlen im Diagramm.

Nummerierte Komponenten des regionalen externen Application Load Balancers (zum Vergrößern klicken)

Wie im Diagramm dargestellt, wird in diesem Beispiel ein regionaler externer Application Load Balancer in einem VPC-Netzwerk in der Region us-west1 mit einem Backend-Dienst und zwei Backend-Instanzgruppen erstellt.

Das Diagramm zeigt Folgendes:

1. Ein VPC-Netzwerk mit zwei Subnetzen:

   1. Ein Subnetz wird für Back-Ends (Instanzgruppen) verwendet. Der primäre IP-Adressbereich ist 10.1.2.0/24.

   2. Das andere Subnetz ist ein Nur-Proxysubnetz in der Region us-west1. Sie müssen in jeder Region eines VPC-Netzwerks, in dem Sie regionale externe Application Load Balancer verwenden, ein Nur-Proxy-Subnetz erstellen. Das Nur-Proxy-Subnetz der Region wird von allen regionalen Load-Balancern in der Region gemeinsam genutzt. Quelladressen von Paketen, die die Load-Balancer an die Back-Ends Ihres Dienstes senden, werden vom Nur-Proxy-Subnetz zugewiesen. In diesem Beispiel hat das Nur-Proxysubnetz für die Region den primären IP-Adressbereich 10.129.0.0/23. Dies ist die für Subnetze empfohlene Größe. Weitere Informationen finden Sie unter Nur-Proxysubnetze.

2. Eine Firewallregel, die Nur-Proxysubnetz-Traffic in Ihrem Netzwerk zulässt. Dies bedeutet, dass Sie eine Regel hinzufügen müssen, die Traffic von den TCP-Ports 80, 443 und 8080 über 10.129.0.0/23 zulässt (in diesem Beispiel der Bereich des Nur-Proxy-Subnetzes). Eine weitere Firewallregel für die Systemdiagnoseprüfungen.

3. Backend-Instanzen.

4. Instanzgruppen:

   1. Verwaltete oder nicht verwaltete Instanzgruppen für Compute Engine-VM-Deployments
   2. NEGs für GKE-Deployments

   Je nach Anforderungen Ihres Deployments können Sie in jeder Zone eine Kombination aus Backend-Gruppentypen verwenden.

5. Eine regionale Systemdiagnose, die die Bereitschaft Ihrer Back-Ends meldet.

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

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

8. Ein regionaler HTTP- oder HTTPS-Zielproxy, der eine Anfrage vom Nutzer empfängt und an die URL-Zuordnung weiterleitet. Konfigurieren Sie für HTTPS eine regionale SSL-Zertifikatsressource. Der Zielproxy kann entweder das SSL-Zertifikat oder das Zertifikatmanager-Zertifikat verwenden, 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.

9. Eine Weiterleitungsregel mit der externen IP-Adresse Ihres Load-Balancers zum Weiterleiten jeder eingehenden Anfrage an den Zielproxy.

   Die externe IP-Adresse, die der Weiterleitungsregel zugeordnet ist, wird mit dem Befehl gcloud compute addresses create reserviert, wie unter IP-Adresse des Load-Balancers reservieren beschrieben.

Netzwerk und Subnetze konfigurieren

Sie benötigen ein VPC-Netzwerk mit zwei Subnetzen: eines für die Back-Ends des Load-Balancers und eines für die Proxys des Load-Balancers. Ein regionaler externer Application Load Balancer ist regional. Traffic innerhalb des VPC-Netzwerks wird an den Load-Balancer weitergeleitet, wenn sich die Quelle des Traffics in einem Subnetz in derselben Region wie der Load-Balancer befindet.

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 lb-network.

• Subnetz für Back-Ends. Ein Subnetz mit dem Namen backend-subnet in der Region us-west1 verwendet 10.1.2.0/24 für seinen primären IP-Bereich.

• Subnetz für Proxys Ein Subnetz mit dem Namen proxy-only-subnet in der Region us-west1 verwendet 10.129.0.0/23 für seinen primären IP-Bereich.

Hinweis: Sie können den Netzwerknamen, die Region und die Parameter für das Subnetz ändern. In den nachfolgenden Schritten dieser Anleitung werden jedoch das Netzwerk, die Region und die Subnetzparameter verwendet, die hier angegeben sind.

Netzwerk und Subnetz für Back-Ends 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 für Name lb-network ein.

4. Im Bereich Subnetze:

   • Legen Sie Modus für Subnetzerstellung auf Benutzerdefiniert fest.
   • Geben Sie im Bereich Neues Subnetz folgende Informationen ein:
     • Name: backend-subnet
     • Region: us-west1
     • IP-Adressbereich: 10.1.2.0/24
   • Klicken Sie auf Fertig.

5. Klicken Sie auf Erstellen.

gcloud

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

   gcloud compute networks create lb-network --subnet-mode=custom
   

2. Erstellen Sie mit dem Befehl gcloud compute networks subnets create ein Subnetz im Netzwerk lb-network in der Region us-west1:

   gcloud compute networks subnets create backend-subnet \
       --network=lb-network \
       --range=10.1.2.0/24 \
       --region=us-west1
   

Terraform

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

resource "google_compute_network" "default" {
  name                    = "lb-network"
  auto_create_subnetworks = false
  routing_mode            = "REGIONAL"
}

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

resource "google_compute_subnetwork" "default" {
  name                       = "backend-subnet"
  ip_cidr_range              = "10.1.2.0/24"
  network                    = google_compute_network.default.id
  private_ipv6_google_access = "DISABLE_GOOGLE_ACCESS"
  purpose                    = "PRIVATE"
  region                     = "us-west1"
  stack_type                 = "IPV4_ONLY"
}

API

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

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks
   {
    "routingConfig": {
      "routingMode": "REGIONAL"
    },
    "name": "lb-network",
    "autoCreateSubnetworks": false
   }
   

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

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks
   {
    "name": "backend-subnet",
    "network": "projects/PROJECT_ID/global/networks/lb-network",
    "ipCidrRange": "10.1.2.0/24",
    "region": "projects/PROJECT_ID/regions/us-west1",
   }
   

Nur-Proxy-Subnetz konfigurieren

Ein Nur-Proxy-Subnetz stellt eine Reihe von IP-Adressen bereit, die Google 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 lb-network verwendet. Pro Region und Netzwerk kann nur ein Nur-Proxy-Subnetz aktiv sein.

Wichtig: Weisen Sie den Back-Ends Ihres Load-Balancers keine Adressen aus dem Nur-Proxy-Subnetz zu. Die IP-Adressen der Backend-Instanzen werden aus einem oder mehreren anderen Subnetzbereichen zugewiesen. Google Cloud reserviert diesen Subnetzbereich für Proxys, die von Google Cloud verwaltet werden.

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 lb-network, den Namen des VPC-Netzwerks.

3. Klicken Sie auf Subnetz hinzufügen.

4. Geben Sie für Name proxy-only-subnet ein.

5. Wählen Sie bei Region die Option us-west1 aus.

6. Setzen Sie Zweck auf Regional verwalteter Proxy.

7. Geben Sie 10.129.0.0/23 als IP-Adressbereich ein.

8. 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-only-subnet \
  --purpose=REGIONAL_MANAGED_PROXY \
  --role=ACTIVE \
  --region=us-west1 \
  --network=lb-network \
  --range=10.129.0.0/23

Terraform

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

resource "google_compute_subnetwork" "proxy_only" {
  name          = "proxy-only-subnet"
  ip_cidr_range = "10.129.0.0/23"
  network       = google_compute_network.default.id
  purpose       = "REGIONAL_MANAGED_PROXY"
  region        = "us-west1"
  role          = "ACTIVE"
}

API

Erstellen Sie das Nur-Proxysubnetz durch die Methode subnetworks.insert und ersetzen Sie PROJECT_ID dabei durch Ihre Projekt-ID.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks
{
  "name": "proxy-only-subnet",
  "ipCidrRange": "10.129.0.0/23",
  "network": "projects/PROJECT_ID/global/networks/lb-network",
  "region": "projects/PROJECT_ID/regions/us-west1",
  "purpose": "REGIONAL_MANAGED_PROXY",
  "role": "ACTIVE"
}

Firewallregeln konfigurieren

In diesem Beispiel werden die folgenden Firewallregeln verwendet:

• fw-allow-health-check. 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-allow-proxies. Eine Regel für eingehenden Traffic, die für die Instanzen mit Load-Balancing gilt und TCP-Traffic über die Ports 80, 443 und 8080 von den verwalteten Proxys des regionalen externen 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 Firewall auf.

   Zu Firewallregeln

2. Klicken Sie auf Firewallregel erstellen, um die Regel zu erstellen, die Google Cloud-Systemdiagnosen zulässt:

   • Name: fw-allow-health-check
   • Netzwerk: lb-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 HTTP auf Port 80 verwenden, um Ihre VMs zu kontaktieren. Es kann HTTPS jedoch nicht auf Port 443 verwenden, um den Kontakt herzustellen.

3. Klicken Sie auf Erstellen.

4. Klicken Sie noch einmal auf Firewallregel erstellen, um die Regel zu erstellen, die Verbindungen von den Proxyservern des Load-Balancers zu den Back-Ends zulässt:

   • Name: fw-allow-proxies
   • Netzwerk: lb-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
   • 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.

5. Klicken Sie auf Erstellen.

gcloud

1. Erstellen Sie die Regel fw-allow-health-check, 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-allow-health-check \
       --network=lb-network \
       --action=allow \
       --direction=ingress \
       --source-ranges=130.211.0.0/22,35.191.0.0/16 \
       --target-tags=load-balanced-backend \
       --rules=tcp
   

2. Erstellen Sie die Regel fw-allow-proxies, um Verbindungen von den Proxys des regionalen externen 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.

   gcloud compute firewall-rules create fw-allow-proxies \
     --network=lb-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" "default" {
  name = "fw-allow-health-check"
  allow {
    protocol = "tcp"
  }
  direction     = "INGRESS"
  network       = google_compute_network.default.id
  priority      = 1000
  source_ranges = ["130.211.0.0/22", "35.191.0.0/16"]
  target_tags   = ["load-balanced-backend"]
}

resource "google_compute_firewall" "allow_proxy" {
  name = "fw-allow-proxies"
  allow {
    ports    = ["443"]
    protocol = "tcp"
  }
  allow {
    ports    = ["80"]
    protocol = "tcp"
  }
  allow {
    ports    = ["8080"]
    protocol = "tcp"
  }
  direction     = "INGRESS"
  network       = google_compute_network.default.id
  priority      = 1000
  source_ranges = ["10.129.0.0/23"]
  target_tags   = ["load-balanced-backend"]
}

API

Erstellen Sie die Firewallregel fw-allow-health-check, indem Sie eine POST-Anfrage an die Methode firewalls.insert senden und dabei PROJECT_ID durch Ihre Projekt-ID ersetzen.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
{
  "name": "fw-allow-health-check",
  "network": "projects/PROJECT-ID/global/networks/lb-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-allow-proxies, um TCP-Traffic im Proxysubnetz 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-allow-proxies",
  "network": "projects/PROJECT_ID/global/networks/lb-network",
  "sourceRanges": [
    "10.129.0.0/23"
  ],
  "targetTags": [
    "load-balanced-backend"
  ],
  "allowed": [
    {
      "IPProtocol": "tcp",
      "ports": [
        "80"
      ]
    },
    {
      "IPProtocol": "tcp",
      "ports": [
        "443"
      ]
    },
    {
      "IPProtocol": "tcp",
      "ports": [
        "8080"
      ]
    }
  ],
  "direction": "INGRESS"
}

Regionalen externen Application Load Balancer mit einem VM-basierten Dienst konfigurieren

In diesem Abschnitt wird die Konfiguration für Dienste erläutert, die auf Compute Engine-VMs ausgeführt werden. Client-VMs stellen eine Verbindung zur IP-Adresse und dem Port her, die Sie in der Weiterleitungsregel konfigurieren. Wenn Ihre Clientanwendungen Traffic an diese IP-Adresse und diesen Port senden, werden ihre Anfragen entsprechend der URL-Zuordnung Ihres regionalen externen Application Load Balancers an Ihre Backend-VMs weitergeleitet.

Im Beispiel auf dieser Seite wird explizit eine reservierte externe IP-Adresse für die Weiterleitungsregel des regionalen externen Application Load Balancers erstellt, statt die Zuweisung einer sitzungsspezifischen externen IP-Adresse zuzulassen. Als Best Practice empfehlen wir, IP-Adressen für Weiterleitungsregeln zu reservieren.

Backend einer verwalteten Instanzgruppe erstellen

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 regionalen externen Application Load Balancers ausgeführt werden. Der Traffic von Clients wird auf diese Backend-Server verteilt. Zu Demonstrationszwecken stellen Back-Ends ihre eigenen Hostnamen bereit.

Console

1. eine Instanzvorlage erstellen 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 l7-xlb-backend-template ein.
   3. Das Bootlaufwerk sollte auf ein Debian-Image wie Debian GNU/Linux 10 (Buster) 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 bei Netzwerk-Tags den Wert load-balanced-backend ein.
      2. Wählen Sie für Netzwerkschnittstellen Folgendes aus:
         • Netzwerk: lb-network
         • Subnetz: backend-subnet

   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://metadata.google.internal/computeMetadata/v1/instance/name)"
      echo "Page served from: $vm_hostname" | \
      tee /var/www/html/index.html
      systemctl restart apache2
      

   7. Klicken Sie auf Erstellen.

2. Erstellen Sie eine verwaltete Instanzgruppe. 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 l7-xlb-backend-example ein.
   4. Wählen Sie für Standort die Option Einzelne Zone aus.
   5. Wählen Sie bei Region die Option us-west1 aus.
   6. Wählen Sie bei Zone die Option us-west1-a aus.
   7. Wählen Sie bei Instanzvorlage die Option l7-xlb-backend-template aus.

   8. Wählen Sie für den Autoscaling-Modus die Option Ein: der Gruppe Instanzen hinzufügen und aus ihr entfernen aus.

      Setzen Sie die Mindestanzahl an Instanzen auf 2 und die maximale Anzahl von Instanzen auf 2 oder mehr.

   9. Klicken Sie auf Erstellen.

gcloud

Bei den gcloud-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 l7-xlb-backend-template \
   --region=us-west1 \
   --network=lb-network \
   --subnet=backend-subnet \
   --tags=load-balanced-backend \
   --image-family=debian-10 \
   --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://metadata.google.internal/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 l7-xlb-backend-example \
       --zone=us-west1-a \
       --size=2 \
       --template=l7-xlb-backend-template
   

Terraform

Verwenden Sie zum Erstellen der Instanzvorlage die Ressource google_compute_instance_template.

resource "google_compute_instance_template" "default" {
  name = "l7-xlb-backend-template"
  disk {
    auto_delete  = true
    boot         = true
    device_name  = "persistent-disk-0"
    mode         = "READ_WRITE"
    source_image = "projects/debian-cloud/global/images/family/debian-10"
    type         = "PERSISTENT"
  }
  labels = {
    managed-by-cnrm = "true"
  }
  machine_type = "n1-standard-1"
  metadata = {
    startup-script = <<EOF
    #! /bin/bash
    sudo apt-get update
    sudo apt-get install apache2 -y
    sudo a2ensite default-ssl
    sudo a2enmod ssl
    vm_hostname="$(curl -H "Metadata-Flavor:Google" \
    http://169.254.169.254/computeMetadata/v1/instance/name)"
    sudo echo "Page served from: $vm_hostname" | \
    tee /var/www/html/index.html
    sudo systemctl restart apache2
    EOF
  }
  network_interface {
    access_config {
      network_tier = "PREMIUM"
    }
    network    = google_compute_network.default.id
    subnetwork = google_compute_subnetwork.default.id
  }
  region = "us-west1"
  scheduling {
    automatic_restart   = true
    on_host_maintenance = "MIGRATE"
    provisioning_model  = "STANDARD"
  }
  service_account {
    email  = "default"
    scopes = ["https://www.googleapis.com/auth/devstorage.read_only", "https://www.googleapis.com/auth/logging.write", "https://www.googleapis.com/auth/monitoring.write", "https://www.googleapis.com/auth/pubsub", "https://www.googleapis.com/auth/service.management.readonly", "https://www.googleapis.com/auth/servicecontrol", "https://www.googleapis.com/auth/trace.append"]
  }
  tags = ["load-balanced-backend"]
}

Verwenden Sie zum Erstellen der verwalteten Instanzgruppe die Ressource google_compute_instance_group_manager.

resource "google_compute_instance_group_manager" "default" {
  name = "l7-xlb-backend-example"
  zone = "us-west1-a"
  named_port {
    name = "http"
    port = 80
  }
  version {
    instance_template = google_compute_instance_template.default.id
    name              = "primary"
  }
  base_instance_name = "vm"
  target_size        = 2
}

API

1. Erstellen Sie die Instanzvorlage mit der Methode instanceTemplates.insert und ersetzen Sie PROJECT_ID durch Ihre Projekt-ID.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/instanceTemplates
   {
    "name":"l7-xlb-backend-template",
    "properties": {
      "machineType":"e2-standard-2",
      "tags": {
        "items":[
          "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\nvm_hostname=\"$(curl -H \"Metadata-Flavor:Google\" \\\nhttp://metadata.google.internal/computeMetadata/v1/instance/name)\"\necho \"Page served from: $vm_hostname\" | \\\ntee /var/www/html/index.html\nsystemctl restart apache2"
          }
        ]
      },
      "networkInterfaces":[
        {
          "network":"projects/PROJECT_ID/global/networks/lb-network",
          "subnetwork":"regions/us-west1/subnetworks/backend-subnet",
          "accessConfigs":[
            {
              "type":"ONE_TO_ONE_NAT"
            }
          ]
        }
      ],
      "disks": [
        {
          "index":0,
          "boot":true,
          "initializeParams": {
            "sourceImage":"projects/debian-cloud/global/images/family/debian-10"
          },
          "autoDelete":true
        }
      ]
    }
   }
   

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

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/{zone}/instanceGroupManagers
   {
    "name": "l7-xlb-backend-example",
    "zone": "projects/PROJECT_ID/zones/us-west1-a",
    "instanceTemplate": "projects/PROJECT_ID/global/instanceTemplates/l7-xlb-backend-template",
    "baseInstanceName": "l7-xlb-backend-example",
    "targetSize": 2
   }
   

Benannten Port zur Instanzgruppe hinzufügen

Legen Sie für Ihre Instanzgruppe einen HTTP-Dienst fest und ordnen Sie dem entsprechenden Port einen Portnamen zu. Der Backend-Dienst des Load-Balancers leitet den Traffic an den benannten Port weiter.

Console

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

   Zu den Instanzgruppen

2. Klicken Sie auf den Namen Ihrer Instanzgruppe (in diesem Beispiel l7-xlb-backend-example).

3. Klicken Sie auf der Seite Übersicht der Instanzgruppe auf Bearbeiten.

4. Klicken Sie auf Portnamenzuordnung festlegen.

5. Klicken Sie auf Zeile hinzufügen.

6. Geben Sie als Portname http ein. Geben Sie als Portnummer 80 ein.

7. Klicken Sie auf Speichern.

gcloud

Führen Sie den Befehl gcloud compute instance-groups set-named-ports aus.

gcloud compute instance-groups set-named-ports l7-xlb-backend-example \
    --named-ports http:80 \
    --zone us-west1-a

Terraform

Das Attribut named_port ist im Beispiel für verwaltete Instanzgruppen enthalten.

IP-Adresse des Load-Balancers reservieren

Externe IP-Adresse für den Load-Balancer reservieren Dieses Verfahren erstellt die IP-Adresse des Load Balancers in der Standardstufe. Regionale externe Application Load Balancer unterstützen sowohl die Premium- als auch die Standard-Netzwerkdienststufen. Das Erstellen dieses Load Balancers in der Premium-Stufe wird in der Google Cloud Console jedoch nicht unterstützt. Verwenden Sie stattdessen gcloud oder die REST API.

Console

1. Rufen Sie in der Google Cloud Console die Seite Statische Adresse reservieren auf.

   Zur Seite "Statische Adresse reservieren"

2. Wählen Sie einen Namen für die neue Adresse aus.

3. Wählen Sie für Netzwerkdienststufe die Option Standard aus.

4. Setzen Sie die IP-Version auf IPv4. IPv6-Adressen sind immer global und können nur mit globalen Load-Balancern verwendet werden.

5. Wählen Sie unter Typ die Option Regional aus.

6. Wählen Sie als Region us-west1 aus.

7. Übernehmen Sie für die Option Verknüpft mit die Einstellung Keine. Nachdem Sie den Load-Balancer erstellt haben, wird diese IP-Adresse an die Weiterleitungsregel des Load-Balancers angehängt.

8. Klicken Sie auf Reservieren, um die IP-Adresse zu reservieren.

gcloud

1. Zum Reservieren einer statischen externen IP-Adresse mit gcloud compute verwenden Sie den Befehl compute addresses create.

   gcloud compute addresses create ADDRESS_NAME  \
      --region=us-west1 \
      --network-tier=STANDARD
   

   Ersetzen Sie Folgendes:

   • ADDRESS_NAME ist der Name, den Sie für diese Adresse vergeben möchten.
   • REGION ist die Region, in der Sie diese Adresse reservieren möchten. Diese Region sollte mit der Region des Load-Balancers übereinstimmen. Alle regionalen IP-Adressen sind IPv4.

2. Verwenden Sie den Befehl compute addresses describe, um das Ergebnis anzeigen zu lassen:

   gcloud compute addresses describe ADDRESS_NAME
   

Terraform

Verwenden Sie zum Reservieren der IP-Adresse die Ressource google_compute_address.

resource "google_compute_address" "default" {
  name         = "address-name"
  address_type = "EXTERNAL"
  network_tier = "STANDARD"
  region       = "us-west1"
}

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

API

Rufen Sie zum Erstellen einer regionalen IPv4-Adresse die regionale Methode addresses.insert auf:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/addresses

Ihre Anfrage sollte folgenden Text enthalten:

{
  "name": "ADDRESS_NAME"
  "networkTier": "STANDARD"
  "region": "us-west1"
}

Dabei gilt:

• ADDRESS_NAME ist der Name der Adresse.
• REGION ist der Name der Region für diese Anfrage.
• PROJECT_ID ist die Projekt-ID für diese Anfrage.

Load-Balancer konfigurieren

In diesem Beispiel wird gezeigt, wie Sie die folgenden Ressourcen für einen regionalen externen Application Load Balancer erstellen:

• HTTP-Systemdiagnose
• Backend-Dienst mit einer verwalteten Instanzgruppe als Backend
• Eine URL-Zuordnung
  • Vergewissern Sie sich, dass Sie auf eine regionale URL-Zuordnung verweisen, wenn eine Region für den HTTP(S)-Zielproxy definiert ist. Eine regionale URL-Zuordnung leitet Anfragen an einen regionalen Back-End-Dienst auf Grundlage von Regeln weiter, die Sie für den Host und den Pfad einer eingehenden URL definieren. Eine regionale URL-Zuordnung kann nur von einer regionalen Zielproxy-Regel in derselben Region referenziert werden.
• SSL-Zertifikat (für HTTPS)
• Zielproxy
• Weiterleitungsregel

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 Application Load Balancer (HTTP/HTTPS) aus und klicken Sie auf Weiter.
4. Wählen Sie für Öffentlich oder intern die Option Öffentlich (extern) aus und klicken Sie auf Weiter.
5. Wählen Sie unter Globale oder Einzelregion-Bereitstellung die Option Am besten für regionale Arbeitslasten aus und klicken Sie auf Weiter.
6. Klicken Sie auf Konfigurieren.

Grundlegende Konfiguration

1. Geben Sie regional-l7-xlb als Name für den Load-Balancer ein.
2. Wählen Sie bei Region die Option us-west1 aus.
3. Wählen Sie für Netzwerk die Option lb-network aus.

Nur-Proxy-Subnetz reservieren

Hinweis: Wenn Sie das Nur-Proxy-Subnetz bereits konfiguriert haben, wird die Schaltfläche Subnetz reservieren nicht angezeigt. You can skip this section and continue with the steps in Configure the frontend service.

Reservieren Sie für regionale regionale Application Load Balancer ein Nur-Proxy-Subnetz:

1. Klicken Sie auf Subnetz reservieren.
2. Geben Sie für Name proxy-only-subnet ein.
3. Geben Sie 10.129.0.0/23 als IP-Adressbereich ein.
4. Klicken Sie auf Add (Hinzufügen).

Frontend konfigurieren

Bei HTTP:

1. Klicken Sie auf Frontend-Konfiguration.
2. Legen Sie als Name l7-xlb-forwarding-rule fest.
3. Legen Sie für Protokoll den Wert HTTP fest.
4. Legen Sie für Port den Wert 80 fest.
5. Wählen Sie die IP-Adresse aus, die Sie unter IP-Adresse des Load-Balancers reservieren erstellt haben.
6. Klicken Sie auf Fertig.

Bei HTTPS:

1. Klicken Sie auf Front-End-Konfiguration.
2. Geben Sie im Feld Name l7-xlb-forwarding-rule ein.
3. Wählen Sie im Feld Protokoll die Option HTTPS (includes HTTP/2) aus.
4. Achten Sie darauf, dass der Port auf 443 festgelegt ist.
5. Wählen Sie die IP-Adresse aus, die Sie unter IP-Adresse des Load-Balancers reservieren erstellt haben.
6. Gehen Sie in der Zertifikatsliste so vor:
   1. Wenn Sie bereits eine selbstverwaltete SSL-Zertifikatsressource von Compute Engine haben, wählen Sie das primäre SSL-Zertifikat aus.
   2. Klicken Sie auf Neues Zertifikat erstellen.
      1. Geben Sie im Feld Name l7-xlb-cert ein.
      2. Laden Sie in den entsprechenden Feldern Ihre PEM-formatierten Dateien hoch:
         • Zertifikat
         • Privater Schlüssel
      3. Klicken Sie auf Erstellen.
7. Optional: So fügen Sie zusätzlich zum primären SSL-Zertifikat Zertifikate hinzu:
   1. Klicken Sie auf Zertifikat hinzufügen.
   2. Wenn Sie bereits ein Zertifikat haben, wählen Sie es aus der Liste Zertifikate aus.
   3. Optional: Klicken Sie auf Neues Zertifikat erstellen und folgen Sie der Anleitung im vorherigen Schritt.
8. 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.
9. Klicken Sie auf Fertig.

Backend-Dienst konfigurieren

1. Klicken Sie auf Backend-Konfiguration.
2. Wählen Sie im Menü Backend-Dienst erstellen oder auswählen die Option Backend-Dienst erstellen aus.
3. Legen Sie l7-xlb-backend-service als Name für den Backend-Dienst fest.
4. Wählen Sie für Protokoll die Option HTTP aus.
5. Geben Sie als Benannter Port http ein.
6. Setzen Sie den Backend-Typ auf Instanzgruppe.
7. In the New backend section:
   1. Legen Sie Instanzgruppe auf l7-xlb-backend-example fest.
   2. Legen Sie für Portnummern den Wert 80 fest.
   3. Setzen Sie den Balancing-Modus auf Auslastung.
   4. Klicken Sie auf Fertig.
8. Klicken Sie im Abschnitt Systemdiagnose auf Systemdiagnose erstellen.
   1. Legen Sie als Name l7-xlb-basic-check fest.
   2. Legen Sie für Protokoll den Wert HTTP fest.
   3. Legen Sie für Port den Wert 80 fest.
   4. Klicken Sie auf Speichern.
9. Klicken Sie auf Erstellen.

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 l7-xlb-backend-service der einzige Backend-Dienst für alle nicht übereinstimmenden Hosts und alle nicht übereinstimmenden Pfade ist.

Konfiguration prüfen

1. Klicken Sie auf Prüfen und abschließen.
2. Prüfen Sie die Konfigurationseinstellungen des Load-Balancers.
3. Optional: Klicken Sie auf Entsprechender Code, um die REST API-Anfrage aufzurufen, die zum Erstellen des Load-Balancers verwendet wird.
4. 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 l7-xlb-basic-check \
      --region=us-west1 \
      --request-path='/' \
      --use-serving-port
   

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

   gcloud compute backend-services create l7-xlb-backend-service \
     --load-balancing-scheme=EXTERNAL_MANAGED \
     --protocol=HTTP \
     --port-name=http \
     --health-checks=l7-xlb-basic-check \
     --health-checks-region=us-west1 \
     --region=us-west1
   

3. Fügen Sie dem Back-End-Dienst mit dem Befehl gcloud compute backend-services add-backend Back-Ends hinzu.

   gcloud compute backend-services add-backend l7-xlb-backend-service \
     --balancing-mode=UTILIZATION \
     --instance-group=l7-xlb-backend-example \
     --instance-group-zone=us-west1-a \
     --region=us-west1
   

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

   gcloud compute url-maps create regional-l7-xlb-map \
     --default-service=l7-xlb-backend-service \
     --region=us-west1
   

5. Erstellen Sie den Zielproxy.

   Bei HTTP:

   Erstellen Sie für einen HTTP-Load-Balancer den Zielproxy mit dem Befehl gcloud compute target-http-proxies create.

   gcloud compute target-http-proxies create l7-xlb-proxy \
     --url-map=regional-l7-xlb-map \
     --url-map-region=us-west1 \
     --region=us-west1
   

   Bei HTTPS:

   Sie können entweder Compute Engine- oder Zertifikatmanager-Zertifikate erstellen. Verwenden Sie eine der folgenden Methoden, um Zertifikate mit Zertifikatmanager zu erstellen:

   • Regionale selbstverwaltete Zertifikate. Informationen zum Erstellen und Verwenden regionaler selbstverwalteter Zertifikate finden Sie unter Regionales selbstverwaltetes Zertifikat bereitstellen. Zertifikatzuordnungen werden nicht unterstützt.

   • Regionale von Google verwaltete Zertifikate. Zertifikatzuordnungen werden nicht unterstützt.

     Die folgenden Typen regionaler, von Google verwalteter Zertifikate werden von Zertifikatmanager unterstützt:

     • Regionale von Google verwaltete Zertifikate mit projektspezifischer DNS-Autorisierung. Weitere Informationen finden Sie unter Regionales von Google verwaltetes Zertifikat bereitstellen.
     • Regionale von Google verwaltete (private) Zertifikate mit Certificate Authority Service. Weitere Informationen finden Sie unter Regionales von Google verwaltetes Zertifikat mit CA Service bereitstellen.

   Nachdem Sie Zertifikate erstellt haben, hängen Sie das Zertifikat direkt an den Zielproxy an.

   1. Weisen Sie Ihre Dateipfade den entsprechenden Variablennamen zu.

      export LB_CERT=path to PEM-formatted file
      

      export LB_PRIVATE_KEY=path to PEM-formatted file
      

   2. Erstellen Sie ein regionales SSL-Zertifikat mit dem Befehl gcloud compute ssl-certificates create.

      gcloud compute ssl-certificates create l7-xlb-cert \
       --certificate=$LB_CERT \
       --private-key=$LB_PRIVATE_KEY \
       --region=us-west1
      

   3. 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 l7-xlb-proxy \
       --url-map=regional-l7-xlb-map \
       --region=us-west1 \
       --ssl-certificates=l7-xlb-cert
      

   • Erstellen Sie die Weiterleitungsregel.

     Bei HTTP:

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

     gcloud compute forwarding-rules create l7-xlb-forwarding-rule \
       --load-balancing-scheme=EXTERNAL_MANAGED \
       --network-tier=STANDARD \
       --network=lb-network \
       --address=ADDRESS_NAME \
       --ports=80 \
       --region=us-west1 \
       --target-http-proxy=l7-xlb-proxy \
       --target-http-proxy-region=us-west1
     

     Bei HTTPS:

     Erstellen Sie die Weiterleitungsregel mit dem Befehl gcloud compute forwarding-rules create und den richtigen Flags.

     gcloud compute forwarding-rules create l7-xlb-forwarding-rule \
       --load-balancing-scheme=EXTERNAL_MANAGED \
       --network-tier=STANDARD \
       --network=lb-network \
       --address=ADDRESS_NAME \
       --ports=443 \
       --region=us-west1 \
       --target-https-proxy=l7-xlb-proxy \
       --target-https-proxy-region=us-west1
     

Terraform

Verwenden Sie zum Erstellen der Systemdiagnose die Ressource google_compute_region_health_check.

resource "google_compute_region_health_check" "default" {
  name               = "l7-xlb-basic-check"
  check_interval_sec = 5
  healthy_threshold  = 2
  http_health_check {
    port_specification = "USE_SERVING_PORT"
    proxy_header       = "NONE"
    request_path       = "/"
  }
  region              = "us-west1"
  timeout_sec         = 5
  unhealthy_threshold = 2
}

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

resource "google_compute_region_backend_service" "default" {
  name                  = "l7-xlb-backend-service"
  region                = "us-west1"
  load_balancing_scheme = "EXTERNAL_MANAGED"
  health_checks         = [google_compute_region_health_check.default.id]
  protocol              = "HTTP"
  session_affinity      = "NONE"
  timeout_sec           = 30
  backend {
    group           = google_compute_instance_group_manager.default.instance_group
    balancing_mode  = "UTILIZATION"
    capacity_scaler = 1.0
  }
}

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

resource "google_compute_region_url_map" "default" {
  name            = "regional-l7-xlb-map"
  region          = "us-west1"
  default_service = google_compute_region_backend_service.default.id
}

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

resource "google_compute_region_target_http_proxy" "default" {
  name    = "l7-xlb-proxy"
  region  = "us-west1"
  url_map = google_compute_region_url_map.default.id
}

Verwenden Sie zum Erstellen der Weiterleitungsregel die Ressource google_compute_forwarding_rule.

resource "google_compute_forwarding_rule" "default" {
  name       = "l7-xlb-forwarding-rule"
  provider   = google-beta
  depends_on = [google_compute_subnetwork.proxy_only]
  region     = "us-west1"

  ip_protocol           = "TCP"
  load_balancing_scheme = "EXTERNAL_MANAGED"
  port_range            = "80"
  target                = google_compute_region_target_http_proxy.default.id
  network               = google_compute_network.default.id
  ip_address            = google_compute_address.default.id
  network_tier          = "STANDARD"
}

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 regionHealthChecks.insert. Ersetzen Sie dabei PROJECT_ID durch Ihre Projekt-ID.

POST https://compute.googleapis.com/compute/v1/projects/<var>PROJECT_ID</var>/regions/{region}/healthChecks
{
  "name": "l7-xlb-basic-check",
  "type": "HTTP",
  "httpHealthCheck": {
    "portSpecification": "USE_SERVING_PORT"
  }
}

Erstellen Sie den regionalen Back-End-Dienst, indem Sie eine POST-Anfrage an die Methode regionBackendServices.insert stellen und dabei PROJECT_ID durch Ihre Projekt-ID ersetzen.

POST https://compute.googleapis.com/compute/v1/projects/<var>PROJECT_ID</var>/regions/us-west1/backendServices
{
  "name": "l7-xlb-backend-service",
  "backends": [
    {
      "group": "projects/<var>PROJECT_ID</var>/zones/us-west1-a/instanceGroups/l7-xlb-backend-example",
      "balancingMode": "UTILIZATION"
    }
  ],
  "healthChecks": [
    "projects/<var>PROJECT_ID</var>/regions/us-west1/healthChecks/l7-xlb-basic-check"
  ],
  "loadBalancingScheme": "EXTERNAL_MANAGED"
}

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

POST https://compute.googleapis.com/compute/v1/projects/<var>PROJECT_ID</var>/regions/us-west1/urlMaps
{
  "name": "regional-l7-xlb-map",
  "defaultService": "projects/<var>PROJECT_ID</var>/regions/us-west1/backendServices/l7-xlb-backend-service"
}

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

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/targetHttpProxy
{
  "name": "l7-xlb-proxy",
  "urlMap": "projects/PROJECT_ID/global/urlMaps/regional-l7-xlb-map",
  "region": "us-west1"
}

Erstellen Sie die Firewallregel POST, indem Sie eine -Anfrage an die Methode forwardingRules.insertPROJECT_ID senden und dabei durch Ihre Projekt-ID ersetzen.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules
{
  "name": "l7-xlb-forwarding-rule",
  "IPAddress": "10.1.2.99",
  "IPProtocol": "TCP",
  "portRange": "80-80",
  "target": "projects/PROJECT_ID/regions/us-west1/targetHttpProxies/l7-xlb-proxy",
  "loadBalancingScheme": "EXTERNAL_MANAGED",
  "network": "projects/PROJECT_ID/global/networks/lb-network",
  "networkTier": "STANDARD",
}

Domain mit dem Load-Balancer verbinden

Notieren Sie sich nach der Erstellung des Load-Balancers die IP-Adresse, die diesem zugewiesen ist, z. B. 30.90.80.100. Wenn Sie Ihre Domain auf den Load-Balancer verweisen möchten, erstellen Sie mit Ihrem Domain-Registrierungsdienst einen A-Eintrag. Wenn Sie Ihrem SSL-Zertifikat mehrere Domains hinzugefügt haben, müssen Sie für jede Domain einen A-Eintrag hinzufügen, der auf die IP-Adresse des Load-Balancers verweist. So erstellen Sie beispielsweise A-Einträge für www.example.com und example.com:

NAME                  TYPE     DATA
www                   A        30.90.80.100
@                     A        30.90.80.100

Wenn Sie Cloud DNS als DNS-Anbieter verwenden, finden Sie weitere Informationen unter Einträge hinzufügen, ändern und löschen.

Load-Balancer testen

Da der Load-Balancing-Dienst nun ausgeführt wird, können Sie Traffic an die Weiterleitungsregel senden. Dieser wird dann an verschiedene Instanzen verteilt.

Console

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

   Load-Balancing aufrufen

2. Wählen Sie den Load-Balancer aus, den Sie gerade erstellt haben.
3. Prüfen Sie im Bereich Backend, ob die VMs fehlerfrei sind. Die Spalte Fehlerfrei sollte ausgefüllt sein; in diesem Fall sind beide VMs fehlerfrei (2/2). Falls sie doch leer ist, aktualisieren Sie zuerst die Seite. Es kann einige Minuten dauern, bis in der Google Cloud Console angezeigt wird, dass die VMs fehlerfrei sind. Wenn die Backends nach einigen Minuten nicht als fehlerfrei angezeigt werden, prüfen Sie die Firewallkonfiguration und das Netzwerk-Tag, das Ihren Backend-VMs zugewiesen wurde.
4. Sobald die Backend-Instanzen in der Google Cloud Console als fehlerfrei angezeigt werden, können Sie den Load-Balancer mit einem Webbrowser testen. Rufen Sie dafür https://IP_ADDRESS (oder http://IP_ADDRESS) auf. Ersetzen Sie IP_ADDRESS durch die IP-Adresse des Load-Balancers.
5. Wenn Sie ein selbst signiertes Zertifikat zu HTTPS-Testzwecken genutzt haben, zeigt Ihr Browser eine Warnung an. Sie müssen Ihren Browser ausdrücklich anweisen, ein selbst signiertes Zertifikat zu akzeptieren.
6. Im Browser sollte eine Seite mit Inhalt dargestellt werden, der den Namen der Instanz, die die Seite bereitstellt, und deren Zone enthält (z. B. Page served from: lb-backend-example-xxxx). Wenn der Browser diese Seite nicht anzeigt, prüfen Sie die Konfigurationseinstellungen aus dieser Anleitung.

gcloud

Notieren Sie sich die reservierte IPv4-Adresse:

gcloud beta compute addresses describe ADDRESS_NAME \
    --format="get(address)" \
    --region="us-west1"

Sie können Ihren Load-Balancer mit einem Webbrowser testen, indem Sie https://IP_ADDRESS (oder http://IP_ADDRESS) aufrufen. Ersetzen Sie IP_ADDRESS durch die IP-Adresse des Load-Balancers.

Wenn Sie ein selbst signiertes Zertifikat genutzt haben, um HTTPS zu testen, zeigt Ihr Browser eine Warnung an. Sie müssen Ihren Browser ausdrücklich anweisen, ein selbst signiertes Zertifikat zu akzeptieren.

Im Browser sollte eine Seite mit minimalen Informationen zur Backend-Instanz angezeigt werden. Wenn diese Seite im Browser nicht angezeigt wird, prüfen Sie die Konfigurationseinstellungen in dieser Anleitung.

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

Mit diesen Verfahren wird gezeigt, wie Sie einen Backend-Dienst für den regionalen externen Application Load Balancer so aktualisieren, dass der Backend-Dienst die generierte Cookie-Affinität, Header-Feld-Affinität oder HTTP-Cookie-Affinität verwendet.

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 oder denselben Backend-Endpunkt weiter. Für regionale externe Application Load Balancer lautet das Cookie GCILB.

Wenn die Header-Feld-Affinität aktiviert ist, leitet der Load-Balancer Anfragen an Backend-VMs oder Endpunkte in einer 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. Wählen Sie den Load-Balancer aus, den Sie gerade erstellt haben.

3. Klicken Sie auf Back-Ends.

4. Klicken Sie auf l7-xlb-backend-service. Das ist der Name des Backend-Dienstes, den Sie für dieses Beispiel erstellt haben. Klicken Sie dann auf Bearbeiten.

5. Klicken Sie auf der Seite Backend-Dienstdetails auf Erweiterte Konfiguration.

6. Wählen Sie unter Sitzungsaffinität die gewünschte Art der Sitzungsaffinität aus dem Menü aus.

7. Klicken Sie auf Aktualisieren.

gcloud

Mit den folgenden gcloud-Befehlen können Sie den Back-End-Dienst l7-xlb-backend-service auf verschiedene Arten der Sitzungsaffinität aktualisieren:

gcloud compute backend-services update l7-xlb-backend-service \
    --session-affinity=[GENERATED_COOKIE | HEADER_FIELD | HTTP_COOKIE | CLIENT_IP]
    --region=us-west1

API

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

PATCH https://compute.googleapis.com/compute/v1/projects/[PROJECT_ID]/regions/us-west1/regionBackendServices/l7-xlb-backend-service
{
  "sessionAffinity": ["GENERATED_COOKIE" | "HEADER_FIELD" | "HTTP_COOKIE" | "CLIENT_IP" ]
}

Nächste Schritte

• Informationen zu den Features zur Traffic-Verwaltung finden Sie in der Übersicht zur Traffic-Verwaltung für regionale externe Application Load Balancer.

• Informationen zum Verwalten der Nur-Proxy-Subnetzressource, die für einen regionalen externen Application Load Balancer erforderlich ist, finden Sie unter Nur-Proxy-Subnetze.

• Informationen zum Aktualisieren des SSL-Zertifikats des regionalen externen Application Load Balancers finden Sie unter Selbstverwaltete SSL-Zertifikate verwenden.

• Einrichtung des Load-Balancers bereinigen