Internen Application Load Balancer mit freigegebener VPC einrichten

Dieses Dokument zeigt zwei Beispielkonfigurationen zum Einrichten eines internen Application Load Balancer in einer Umgebung mit freigegebener VPC:

• Im ersten Beispiel werden alle Load-Balancer-Komponenten und Back-Ends im Dienstprojekt erstellt.
• Im zweiten Beispiel werden die Frontend-Komponenten und die URL-Zuordnung des Load-Balancers in einem Dienstprojekt erstellt, während der Backend-Dienst und die Backends des Load-Balancers in einem anderen Dienstprojekt erstellt werden. Diese Art der Bereitstellung, bei der die URL-Zuordnung auf einen Backend-Dienst in einem anderen Projekt verweist, wird als projektübergreifender Dienstverweis bezeichnet.

Beide Beispiele erfordern dieselbe Vorabkonfiguration, um Berechtigungen zu erteilen und eine freigegebene VPC einzurichten, bevor Sie Load-Balancer erstellen können.

Dies sind nicht die einzigen Konfigurationen für freigegebene VPCs, die von internen Application Load Balancern unterstützt werden. Weitere Architekturen mit freigegebener VPC finden Sie unter Architekturen freigegebener VPCs.

Wenn Sie kein freigegebenes VPC-Netzwerk verwenden möchten, finden Sie weitere Informationen unter Internen Application Load Balancer einrichten.

Hinweis:

Für regionenübergreifende interne Application Load Balancer können Sie alle in diesem Dokument bereitgestellten Beispiele für freigegebene VPCs verwenden.

Informationen zum Konfigurieren von regionenübergreifenden internen Application Load Balancern finden Sie unter Regionenübergreifenden internen Application Load Balancer mit VM-Instanzgruppen-Back-Ends einrichten.

Hinweise

1. Weitere Informationen finden Sie unter Freigegebene VPC – Übersicht.
2. Weitere Informationen finden Sie unter Übersicht über den internen Application Load Balancer, einschließlich des Abschnitts Architekturen freigegebener VPCs.

Erforderliche Berechtigungen

Das Einrichten eines Load-Balancers in einem freigegebenen VPC-Netzwerk erfordert eine Ersteinrichtung und -bereitstellung durch einen Administrator. Nach der Ersteinrichtung kann ein Dienstprojektinhaber einen der folgenden Schritte ausführen:

• Stellen Sie alle Komponenten des Load-Balancers und seine Back-Ends in einem Dienstprojekt bereit.
• Stellen Sie die Backend-Komponenten des Load-Balancers (Backend-Dienst und Backends) in Dienstprojekten bereit, auf die in einer URL-Zuordnung in einem anderen Dienst oder Hostprojekt verwiesen werden kann.

In diesem Abschnitt werden die Berechtigungen zusammengefasst, die zum Einrichten eines Load-Balancers in einem freigegebenen VPC-Netzwerk nach dieser Anleitung erforderlich sind.

Freigegebene VPC einrichten

Die folgenden Rollen sind für die folgenden Aufgaben erforderlich:

1. Einmalige administrative Aufgaben wie das Einrichten der freigegebenen VPC und das Aktivieren eines Hostprojekts ausführen
2. Führen Sie administrative Aufgaben aus, die jedes Mal wiederholt werden müssen, wenn Sie ein neues Dienstprojekt aufnehmen möchten. Dies umfasst das Anhängen des Dienstprojekts, das Bereitstellen und Konfigurieren von Netzwerkressourcen und das Gewähren des Zugriffs für den Dienstprojektadministrator.

Diese Aufgaben müssen im Hostprojekt der freigegebenen VPC ausgeführt werden. Wir empfehlen, dass der Administrator der freigegebenen VPC auch der Inhaber des Hostprojekts der freigegebenen VPC ist. Dadurch werden automatisch die Rollen Netzwerkadministrator und Sicherheitsadministrator zugewiesen.

Aufgabe	Erforderliche Rolle
Richten Sie eine freigegebene VPC ein, aktivieren Sie das Hostprojekt und gewähren Sie Dienstprojektadministratoren Zugriff	Shared VPC-Administrator
Erstellen Sie Subnetze im freigegebenen VPC-Hostprojekt und gewähren Sie Dienstprojektadministratoren Zugriff	Netzwerkadministrator
Firewallregeln hinzufügen und löschen	Sicherheitsadministrator

Nachdem die Subnetze bereitgestellt wurden, muss der Inhaber des Hostprojekts die Rolle des Netzwerknutzers im Hostprojekt allen Nutzern (in der Regel Dienstprojektadministratoren, -entwickler oder Dienstkonten) zuweisen, die Zugriff auf diese Ressourcen benötigen.

Aufgabe	Erforderliche Rolle
VPC-Netzwerke und Subnetze verwenden, die zum Hostprojekt gehören	Netzwerknutzer

Diese Rolle kann auf Projektebene oder für einzelne Subnetze gewährt werden. Wir empfehlen, die Rolle für einzelne Subnetze zu gewähren. Durch das Gewähren der Rolle für das Projekt wird Zugriff auf alle aktuellen und zukünftigen Subnetze im VPC-Netzwerk des Hostprojekts gewährt.

Load-Balancer und Back-Ends bereitstellen

Dienstprojektadministratoren benötigen die folgenden Rollen im Dienstprojekt, um Load-Balancing-Ressourcen und Back-Ends zu erstellen. Diese Berechtigungen werden dem Inhaber oder Bearbeiter des Dienstprojekts automatisch erteilt.

Aufgabe	Erforderliche Rolle
Load-Balancer-Komponenten erstellen	Netzwerkadministrator
Instanzen erstellen	Instanzadministrator
SSL-Zertifikate erstellen und ändern	Sicherheitsadministrator

Projektübergreifende Backend-Dienste referenzieren

Wenn Ihr Load-Balancer auf Backend-Dienste aus anderen Dienstprojekten verweisen muss, die auch als projektübergreifende Dienstreferenz bezeichnet werden, benötigen Load-Balancer-Administratoren die folgende Rolle im Dienstprojekt, in dem der Backend-Dienst erstellt wird.

Aufgabe	Erforderliche Rolle
Berechtigungen zur Verwendung von Diensten in anderen Projekten	Load-Balancer-Dienstnutzer

Diese Rolle kann entweder auf Projektebene oder für einzelne Backend-Dienste gewährt werden. Eine Anleitung zum Zuweisen dieser Rolle finden Sie auf dieser Seite im Beispiel für den projektübergreifenden Dienstverweis.

Weitere Informationen zu IAM finden Sie in den folgenden Anleitungen:

• Zugriffskontrolle
• IAM-Bedingungen

Vorbereitung

Führen Sie in diesem Abschnitt die folgenden Schritte aus:

1. Netzwerk und Subnetze im Hostprojekt konfigurieren.
2. Freigegebene VPC im Hostprojekt einrichten.

Die Schritte in diesem Abschnitt müssen nicht jedes Mal ausgeführt werden, wenn Sie einen neuen Load-Balancer erstellen möchten. Sie müssen jedoch sicherstellen, dass Sie Zugriff auf die hier beschriebenen Ressourcen haben, bevor Sie mit dem Erstellen des Load-Balancers fortfahren.

Netzwerk und Subnetze im Hostprojekt konfigurieren

Sie benötigen ein freigegebenes VPC-Netzwerk mit zwei Subnetzen: eines für das Frontend und die Back-Ends des Load-Balancers und das andere für die Proxys des Load-Balancers.

In diesem Beispiel werden die folgenden Netzwerke, Regionen und Subnetze verwendet:

• Netzwerk: Das Netzwerk hat den Namen lb-network.

• Subnetz für das Frontend und die Back-Ends des Load-Balancers: Ein Subnetz mit dem Namen lb-frontend-and-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 weiteren Schritten dieser Anleitung werden jedoch das Netzwerk, die Region und die Subnetzparameter verwendet, die hier angegeben sind.

Subnetz für das Frontend und die Back-Ends des Load-Balancers konfigurieren

Dieser Schritt muss nicht jedes Mal ausgeführt werden, wenn Sie einen neuen Load-Balancer erstellen möchten. Sie müssen nur sicherstellen, dass das Dienstprojekt Zugriff auf ein Subnetz im freigegebenen VPC-Netzwerk hat (zusätzlich zum Nur-Proxy-Subnetz).

Alle Schritte in diesem Abschnitt müssen im Hostprojekt ausgeführt werden.

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:

   1. Legen Sie Modus für Subnetzerstellung auf Benutzerdefiniert fest.

   2. Geben Sie im Bereich Neues Subnetz folgende Informationen ein:

      • Name: lb-frontend-and-backend-subnet

      • Region: us-west1

      • IP-Adressbereich: 10.1.2.0/24

   3. Klicken Sie auf Fertig.

5. Klicken Sie auf Erstellen.

gcloud

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

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

2. Erstellen Sie ein Subnetz im Netzwerk lb-network in der Region us-west1:

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

Terraform

1. Erstellen Sie ein VPC-Netzwerk:

   # Shared VPC network
   resource "google_compute_network" "lb_network" {
     name                    = "lb-network"
     provider                = google-beta
     project                 = "my-host-project-id"
     auto_create_subnetworks = false
   }

2. Erstellen Sie ein Subnetz in der Region us-west1:

   # Shared VPC network - backend subnet
   resource "google_compute_subnetwork" "lb_frontend_and_backend_subnet" {
     name          = "lb-frontend-and-backend-subnet"
     provider      = google-beta
     project       = "my-host-project-id"
     region        = "us-west1"
     ip_cidr_range = "10.1.2.0/24"
     role          = "ACTIVE"
     network       = google_compute_network.lb_network.id
   }

Nur-Proxy-Subnetz konfigurieren

Das Nur-Proxy-Subnetz wird von allen regionalen Envoy-basierten Load-Balancern in der Region us-west1 im VPC-Netzwerk lb-network verwendet. Pro Region und Netzwerk kann nur ein Nur-Proxy-Subnetz aktiv sein.

Führen Sie diesen Schritt nicht aus, wenn bereits ein Nur-Proxy-Subnetz in der Region us-west1 in diesem Netzwerk reserviert ist.

Wichtig: Versuchen Sie nicht, der Weiterleitungsregel oder den Back-Ends Ihres Load-Balancers IP-Adressen aus diesem Nur-Proxy-Subnetz zuzuweisen. Die IP-Adresse der Weiterleitungsregel und die IP-Adressen der Backend-Instanzen werden aus einem anderen oder mehreren anderen Subnetzbereichen zugewiesen. Google Cloud reserviert diesen Subnetzbereich für Proxys, die von Google Cloud verwaltet werden.

Alle Schritte in diesem Abschnitt müssen im Hostprojekt ausgeführt werden.

Console

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

   Zur Seite VPC-Netzwerke

2. Klicken Sie auf den Namen des freigegebenen VPC-Netzwerks: lb-network.
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

Erstellen Sie das Nur-Proxy-Subnetz:

# Shared VPC network - proxy-only subnet
resource "google_compute_subnetwork" "proxy_only_subnet" {
  name          = "proxy-only-subnet"
  provider      = google-beta
  project       = "my-host-project-id"
  region        = "us-west1"
  ip_cidr_range = "10.129.0.0/23"
  role          = "ACTIVE"
  purpose       = "REGIONAL_MANAGED_PROXY"
  network       = google_compute_network.lb_network.id
}

Gewähren Sie Dienstprojektadministratoren Zugriff auf das Backend-Subnetz

Dienstprojektadministratoren benötigen Zugriff auf das Subnetz lb-frontend-and-backend-subnet, damit sie die Back-Ends des Load-Balancers bereitstellen können.

Ein Administrator der freigegebenen VPC muss Dienstprojektadministratoren Zugriff auf das Backend-Subnetz gewähren (oder auch Entwicklern, die Ressourcen und Backends bereitstellen, die das Subnetz verwenden). Eine Anleitung finden Sie unter Dienstprojektadministratoren für bestimmte Subnetze.

Hinweis: Dienstprojektadministratoren benötigen keinen Zugriff auf das Nur-Proxy-Subnetz. Ohne ein bereits vorhandenes Nur-Proxy-Subnetz in der Region können Dienstprojektadministratoren jedoch keine Weiterleitungsregeln für regionale Envoy-basierte Load-Balancer in dieser Region erstellen.

Firewallregeln im Hostprojekt 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 TCP-Traffic von den Google Cloud-Systemen für Systemdiagnosen zulässt (in 130.211.0.0/22 und 35.191.0.0/16). In diesem Beispiel wird das Ziel-Tag load-balanced-backend verwendet, um die Instanzen zu identifizieren, auf die es angewendet werden soll.

• fw-allow-proxies: Eine Regel für eingehenden Traffic, die für die Instanzen mit Load-Balancing gilt und TCP-Traffic über Ports 80 ,443 und 8080 aus den verwalteten Proxys des Load-Balancers zulässt. In diesem Beispiel wird das Ziel-Tag load-balanced-backend verwendet, um die Instanzen zu identifizieren, auf die sie angewendet werden soll.

• fw-allow-ssh: 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 Quell-IP-Bereich für diese Regel auswählen. Sie können beispielsweise nur die IP-Bereiche des Systems angeben, von dem aus Sie SSH-Sitzungen initiieren. In diesem Beispiel wird das Ziel-Tag allow-ssh verwendet, um die VMs zu identifizieren, auf welche die Firewallregel angewendet wird.

Without these firewall rules, the default deny ingress rule blocks incoming traffic to the backend instances.

Alle Schritte in diesem Abschnitt müssen im Hostprojekt ausgeführt werden.

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 Google Cloud-Systemdiagnosen zulässt:
• Name: fw-allow-health-check
• Netzwerk: lb-network
• Trafficrichtung: Eingehend
• Aktion bei Übereinstimmung: Zulassen
• Ziele: Angegebene Zieltags
• 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.
  • Prüfen Sie TCP 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.

3. Klicken Sie auf Erstellen.
4. Klicken Sie auf Firewallregel erstellen, um die Regel zu erstellen, die Google Cloud-Systemdiagnosen zulässt:
• Name: fw-allow-proxies
• Netzwerk: lb-network
• Trafficrichtung: Eingehend
• Aktion bei Übereinstimmung: Zulassen
• Ziele: Angegebene Zieltags
• 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.
  • Prüfen Sie TCP und geben Sie 80, 443, 8080 als Portnummern ein.
5. Klicken Sie auf Erstellen.
6. Klicken Sie auf Firewallregel erstellen, um die Regel zu erstellen, die Google Cloud-Systemdiagnosen zulässt:
• Name: fw-allow-ssh
• Netzwerk: lb-network
• Trafficrichtung: Eingehend
• Aktion bei Übereinstimmung: Zulassen
• Ziele: Angegebene Zieltags
• Zieltags: allow-ssh
• Quellfilter: IPv4-Bereiche.
• IPv4-Quellbereiche: 0.0.0.0/0
• Protokolle und Ports:
  • Wählen Sie Angegebene Protokolle und Ports aus.
  • Prüfen Sie TCP und geben Sie 22 als Portnummer ein.
7. Klicken Sie auf Erstellen.

gcloud

1. Erstellen Sie die Firewallregel fw-allow-health-check, um Google Cloud-Systemdiagnosen zuzulassen. In diesem Beispiel wird der gesamte TCP-Traffic von Systemdiagnoseprüfern 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 Firewallregel fw-allow-proxies, um Traffic von dem Nur-Proxy-Subnetz zuzulassen, das Ihre Back-Ends erreicht.

   gcloud compute firewall-rules create fw-allow-proxies \
      --network=lb-network \
      --action=allow \
      --direction=ingress \
      --source-ranges=10.129.0.0/23 \
      --target-tags=load-balanced-backend \
      --rules=tcp:80,tcp:443,tcp:8080
   

3. Erstellen Sie die Firewallregel fw-allow-ssh, 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-allow-ssh \
      --network=lb-network \
      --action=allow \
      --direction=ingress \
      --target-tags=allow-ssh \
      --rules=tcp:22
   

Terraform

1. Erstellen Sie eine Firewallregel, um Google Cloud-Systemdiagnosen zuzulassen.

   resource "google_compute_firewall" "fw_allow_health_check" {
     name          = "fw-allow-health-check"
     provider      = google-beta
     project       = "my-host-project-id"
     direction     = "INGRESS"
     network       = google_compute_network.lb_network.id
     source_ranges = ["130.211.0.0/22", "35.191.0.0/16"]
     allow {
       protocol = "tcp"
     }
     target_tags = ["load-balanced-backend"]
   }

2. Erstellen Sie eine Firewallregel, um Traffic vom Nur-Proxy-Subnetz zuzulassen und Ihre Back-Ends zu erreichen.

   resource "google_compute_firewall" "fw_allow_proxies" {
     name          = "fw-allow-proxies"
     provider      = google-beta
     project       = "my-host-project-id"
     direction     = "INGRESS"
     network       = google_compute_network.lb_network.id
     source_ranges = ["10.129.0.0/23"]
     allow {
       protocol = "tcp"
       ports    = ["80", "443", "8080"]
     }
     target_tags = ["load-balanced-backend"]
   }

3. Erstellen Sie die Firewallregel, um SSH-Verbindungen zu VMs mit dem Netzwerk-Tag allow-ssh zu ermöglichen.

   resource "google_compute_firewall" "fw_allow_ssh" {
     name          = "fw-allow-ssh"
     provider      = google-beta
     project       = "my-host-project-id"
     direction     = "INGRESS"
     network       = google_compute_network.lb_network.id
     source_ranges = ["0.0.0.0/0"]
     allow {
       protocol = "tcp"
       ports    = ["22"]
     }
     target_tags = ["allow-ssh"]
   }

   
   

Freigegebene VPC im Hostprojekt einrichten

Dieser Schritt umfasst das Aktivieren eines freigegebenen VPC-Hostprojekts, das Freigeben von Subnetzen des Hostprojekts und das Anhängen von Dienstprojekten an das Hostprojekt, damit die Dienstprojekte das freigegebene VPC-Netzwerk verwenden können. Informationen zum Einrichten einer freigegebenen VPC im Hostprojekt finden Sie auf den folgenden Seiten:

• Hostprojekt aktivieren.
• Dienstprojekt anhängen

Hinweis: Für verwaltete Instanzgruppen, die mit einer freigegebenen VPC verwendet werden, muss das Google APIs-Dienstkonto ein Dienstprojektadministrator sein. Dies liegt daran, dass Aufgaben wie die automatische Instanzerstellung per Autoscaling über diese Art von Dienstkonto ausgeführt werden. Informationen zum Definieren des Google APIs-Dienstkontos als Dienstprojektadministrator für das Subnetz im freigegebenen VPC-Hostprojekt finden Sie unter Google APIs-Dienstkonto als Dienstprojektadministrator.

In den weiteren Anleitungen wird davon ausgegangen, dass Sie die freigegebene VPC bereits eingerichtet haben. Dazu müssen Sie IAM-Richtlinien für Ihre Organisation einrichten und die Host- und Dienstprojekte festlegen.

Fahren Sie erst fort, wenn Sie die freigegebene VPC eingerichtet und die Host- und Dienstprojekte aktiviert haben.

Load-Balancer im Dienstprojekt konfigurieren

In diesem Beispiel wird ein interner Application Load Balancer erstellt, bei dem alle Load-Balancing-Komponenten (Weiterleitungsregel, Ziel-Proxy, URL-Zuordnung und Backend-Dienst) und Backends im Dienstprojekt erstellt werden.

Die Netzwerkressourcen des internen Application Load Balancers wie das Nur-Proxy-Subnetz und das Subnetz für die Backend-Instanzen werden im Hostprojekt erstellt. Die Firewallregeln für die Backend-Instanzen werden auch im Hostprojekt erstellt.

Abbildung 1. Interner Application Load Balancer in freigegebener VPC

In diesem Abschnitt erfahren Sie, wie Sie den Load-Balancer und die Back-Ends einrichten. Diese Schritte sollten vom Dienstprojektadministrator (oder einem innerhalb des Dienstprojekts tätigen Entwickler) durchgeführt werden und erfordern keine Einbeziehung des Hostprojektadministrators. Die Schritte in diesem Abschnitt ähneln weitgehend den Standardschritten zum Einrichten eines internen Application Load Balancer.

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

Backend der verwalteten Instanzgruppe erstellen

Hinweis: In diesem Abschnitt erfahren Sie, wie Sie einen internen Application Load Balancer mit VM-Instanzen in einem Dienstprojekt einrichten. Interne Application Load Balancer unterstützen auch eine freigegebene VPC mit Pods in einem GKE-Cluster. Dabei wird containernatives Load-Balancing mit Netzwerk-Endpunktgruppen (NEGs) verwendet.

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

Console

1. Erstellen Sie eine Instanzvorlage. 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-ilb-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. Wenn Sie das Bootlaufwerk ändern müssen, klicken Sie auf Ändern.
      1. Wählen Sie als Betriebssystem die Option Debian aus.
      2. Wählen Sie für Version eines der verfügbaren Debian-Images aus, z. B. Debian GNU/Linux 10 (buster).
      3. Klicken Sie auf Auswählen.
   4. Klicken Sie auf Erweiterte Optionen und dann auf Netzwerk.
   5. Geben Sie die folgenden Netzwerk-Tags ein: allow-ssh,load-balanced-backend.
   6. Wählen Sie im Bereich Netzwerkschnittstellen die Option Für mich freigegebene Netzwerke (von Hostprojekt: HOST_PROJECT_ID) aus.
   7. Wählen Sie das Subnetz lb-frontend-and-backend-subnet aus dem Netzwerk lb-network aus.
   8. Klicken Sie auf Verwaltung. Fügen Sie unter Verwaltung das folgende Skript in das Feld Startskript 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
       

   9. 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-ilb-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-ilb-backend-template aus.

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

      Geben Sie für dieses Beispiel für 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.

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 einem HTTP-Server.

   gcloud compute instance-templates create l7-ilb-backend-template \
   --region=us-west1 \
   --network=projects/HOST_PROJECT_ID/global/networks/lb-network \
   --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
   --tags=allow-ssh,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' \
   --project=SERVICE_PROJECT_ID
   

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-ilb-backend-example \
       --zone=us-west1-a \
       --size=2 \
       --template=l7-ilb-backend-template \
       --project=SERVICE_PROJECT_ID
   

Terraform

1. VM-Instanzvorlage erstellen

   # Instance template
   resource "google_compute_instance_template" "default" {
     name     = "l7-ilb-backend-template"
     provider = google-beta
     project  = "my-service-project-id"
     region   = "us-west1"
     # For machine type, using small. For more options check https://cloud.google.com/compute/docs/machine-types
     machine_type = "e2-small"
     tags         = ["allow-ssh", "load-balanced-backend"]
     network_interface {
       network    = google_compute_network.lb_network.id
       subnetwork = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
       access_config {
         # add external ip to fetch packages like apache2, ssl
       }
     }
     disk {
       source_image = "debian-cloud/debian-10"
       auto_delete  = true
       boot         = true
     }
   
     # install apache2 and serve a simple web page
     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://metadata.google.internal/computeMetadata/v1/instance/name)"
       sudo echo "Page served from: $vm_hostname" | \
       tee /var/www/html/index.html
       sudo systemctl restart apache2
       EOF
     }
   }

2. Erstellen Sie eine verwaltete Instanzgruppe.

   Bei HTTP:

   # MIG
   resource "google_compute_instance_group_manager" "default" {
     name               = "l7-ilb-backend-example"
     provider           = google-beta
     project            = "my-service-project-id"
     zone               = "us-west1-a"
     base_instance_name = "vm"
     target_size        = 2
     version {
       instance_template = google_compute_instance_template.default.id
       name              = "primary"
     }
     named_port {
       name = "http"
       port = 80
     }
   }

   Bei HTTPS:

   # MIG
   resource "google_compute_instance_group_manager" "default" {
     name               = "l7-ilb-backend-example"
     provider           = google-beta
     project            = "my-service-project-id"
     zone               = "us-west1-a"
     base_instance_name = "vm"
     target_size        = 2
     version {
       instance_template = google_compute_instance_template.default.id
       name              = "primary"
     }
     named_port {
       name = "https"
       port = 443
     }
   }

Load-Balancer konfigurieren

In diesem Abschnitt erfahren Sie, wie Sie die Ressourcen für den internen Application Load Balancer erstellen:

• HTTP-Systemdiagnose
• Backend-Dienst mit einer verwalteten Instanzgruppe als Backend
• Eine URL-Zuordnung
• SSL-Zertifikat (nur für HTTPS erforderlich)
• Zielproxy
• Weiterleitungsregel

Proxyverfügbarkeit

Je nach Anzahl der Dienstprojekte, die dasselbe freigegebene VPC-Netzwerk verwenden, werden Kontingente oder Limits möglicherweise schneller ausgeschöpft als im Netzwerkbereitstellungsmodell, in dem jedes Google Cloud-Projekt sein eigenes Netzwerk hostet.

Beispielsweise haben Google Cloud-Regionen manchmal nicht genügend Proxy-Kapazität für einen neuen internen Application 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:

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

• Wenden Sie sich an Ihr Google Cloud-Vertriebsteam, um diese Limits zu erhöhen.

Console

Kontext zum Dienstprojekt wechseln

1. Öffnen Sie in der Google Cloud Console die Seite Dashboard.

   Zum Dashboard

2. Klicken Sie oben auf der Seite auf die Liste Auswählen aus. Wählen Sie im angezeigten Fenster Auswählen aus das Dienstprojekt aus, in dem Sie den Load-Balancer erstellen möchten.

Konfiguration starten

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

   Load-Balancing aufrufen

2. Klicken Sie auf Load-Balancer erstellen.
3. Wählen Sie unter Typ des Load Balancers die Option Application Load Balancer (HTTP/HTTPS) aus und klicken Sie auf Weiter.
4. Wählen Sie für Öffentlich oder intern die Option Intern aus und klicken Sie auf Weiter.
5. Wählen Sie für Regionenübergreifende oder 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 l7-ilb-shared-vpc als Name für den Load-Balancer ein.
2. Wählen Sie us-west1 als Region aus.

3. Wählen Sie für das Netzwerk die Option lb-network (aus Projekt: HOST_PROJECT_ID) aus.

   Wenn die Warnung Nur-Proxy-Subnetz im freigegebenen VPC-Netzwerk erforderlich angezeigt wird, prüfen Sie, ob der Administrator des Hostprojekts das proxy-only-subnet in der Region us-west1 im freigegebenen VPC-Netzwerk lb-network erstellt hat. Die Erstellung des Load-Balancers ist auch dann erfolgreich, wenn Sie keine Berechtigung zum Ansehen des Nur-Proxy-Subnetzes auf dieser Seite haben.

4. Lassen Sie das Fenster geöffnet, um fortzufahren.

Backend konfigurieren

1. Klicken Sie auf Backend-Konfiguration.
2. Wählen Sie im Menü Back-End-Service erstellen oder auswählen die Option Back-End-Service erstellen aus.
3. Legen Sie als Name für den Back-End-Dienst l7-ilb-backend-service fest.
4. Setzen Sie den Backend-Typ auf Instanzgruppen.
5. In the New backend section:
   1. Legen Sie für Instanzgruppe l7-ilb-backend-example fest.
   2. Setzen Sie die Portnummern auf 80.
   3. Setzen Sie den Balancing-Modus auf Auslastung.
   4. Klicken Sie auf Fertig.
6. Wählen Sie im Abschnitt Systemdiagnose die Option Systemdiagnose erstellen mit den folgenden Parametern aus:
   1. Name: l7-ilb-basic-check
   2. Protokoll: HTTP
   3. Port: 80
7. Klicken Sie auf Speichern und Fortfahren.
8. Klicken Sie auf Erstellen.

Routingregeln konfigurieren

• Klicken Sie auf Routingregeln. Achten Sie darauf, dass l7-ilb-backend-service der einzige Back-End-Dienst für alle nicht übereinstimmenden Hosts und alle nicht übereinstimmenden Pfade ist.

Weitere Informationen zur Trafficverwaltung finden Sie unter Trafficverwaltung einrichten.

Frontend konfigurieren

Bei HTTP:

1. Klicken Sie auf Frontend-Konfiguration.
2. Legen Sie als Name l7-ilb-forwarding-rule fest.
3. Legen Sie als Protokoll HTTP fest.
4. Setzen Sie die Option Subnetzwerk auf lb-frontend-and-backend-subnet. Wählen Sie nicht das Nur-Proxy-Subnetz für das Frontend aus, auch wenn es sich um eine Option in der Liste handelt.
5. Legen Sie als Port 80 fest.
6. Klicken Sie auf das Menü IP-Adresse und dann auf IP-Adresse erstellen.
7. Geben Sie im Bereich Statische interne IP-Adresse reservieren die folgenden Informationen an:
   1. Geben Sie im Feld Name ip-address-shared-vpc ein.
   2. Klicken Sie unter Statische IP-Adresse auf Selbst auswählen. Geben Sie als Benutzerdefinierte IP-Adresse 10.1.2.99 ein.
   3. (Optional) Wenn Sie diese IP-Adresse für verschiedene Front-Ends freigeben möchten, setzen Sie den Zweck auf Freigegeben.
8. Klicken Sie auf Fertig.

Bei HTTPS:

Wenn Sie HTTPS zwischen dem Client und dem Load-Balancer verwenden, benötigen Sie eine oder mehrere SSL-Zertifikatsressourcen, um den Proxy zu konfigurieren. Informationen zum Erstellen von SSL-Zertifikatsressourcen finden Sie unter SSL-Zertifikate. Von Google verwaltete Zertifikate werden derzeit nicht von internen Application Load Balancern unterstützt.

1. Klicken Sie auf Frontend-Konfiguration.
2. Geben Sie im Feld Name l7-ilb-forwarding-rule ein.
3. Wählen Sie im Feld Protokoll die Option HTTPS (includes HTTP/2) aus.
4. Setzen Sie die Option Subnetzwerk auf lb-frontend-and-backend-subnet. Wählen Sie nicht das Nur-Proxy-Subnetz für das Frontend aus, auch wenn es sich um eine Option in der Liste handelt.
5. Achten Sie darauf, dass der Port auf 443 festgelegt ist, um HTTPS-Traffic zuzulassen.
6. Klicken Sie auf das Menü IP-Adresse und dann auf IP-Adresse erstellen.
7. Geben Sie im Bereich Statische interne IP-Adresse reservieren die folgenden Informationen an:
   1. Geben Sie im Feld Name ip-address-shared-vpc ein.
   2. Klicken Sie unter Statische IP-Adresse auf Selbst auswählen. Geben Sie als Benutzerdefinierte IP-Adresse 10.1.2.99 ein.
   3. (Optional) Wenn Sie diese IP-Adresse für verschiedene Front-Ends freigeben möchten, setzen Sie den Zweck auf Freigegeben.
8. Klicken Sie auf die Liste Zertifikat.
   1. Wenn Sie bereits eine selbstverwaltete SSL-Zertifikatsressource haben, die Sie als primäres SSL-Zertifikat verwenden möchten, wählen Sie diese aus dem Menü aus.
   2. Wählen Sie andernfalls Neues Zertifikat erstellen aus.
      1. Geben Sie l7-ilb-cert als Name ein.
      2. Laden Sie in den entsprechenden Feldern Ihre PEM-formatierten Dateien hoch:
         • Public-Key-Zertifikat
         • Zertifikatskette
         • Privater Schlüssel
      3. Klicken Sie auf Erstellen.
9. So fügen Sie zusätzlich zur primären SSL-Zertifikatsressource weitere Zertifikatsressourcen hinzu:
   1. Klicken Sie auf Zertifikat hinzufügen.
   2. Wählen Sie ein Zertifikat aus der Liste Zertifikate aus oder klicken Sie auf Neues Zertifikat erstellen und folgen Sie der vorherigen Anleitung.
10. Klicken Sie auf Fertig.

Konfiguration prüfen und fertigstellen

• 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-ilb-basic-check \
      --region=us-west1 \
      --use-serving-port \
      --project=SERVICE_PROJECT_ID
   

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

   gcloud compute backend-services create l7-ilb-backend-service \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --protocol=HTTP \
     --health-checks=l7-ilb-basic-check \
     --health-checks-region=us-west1 \
     --region=us-west1 \
     --project=SERVICE_PROJECT_ID
   

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-ilb-backend-service \
     --balancing-mode=UTILIZATION \
     --instance-group=l7-ilb-backend-example \
     --instance-group-zone=us-west1-a \
     --region=us-west1 \
     --project=SERVICE_PROJECT_ID
   

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

   gcloud compute url-maps create l7-ilb-map \
     --default-service=l7-ilb-backend-service \
     --region=us-west1 \
     --project=SERVICE_PROJECT_ID
   

5. Erstellen Sie den Zielproxy.

   Bei HTTP:

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

   gcloud compute target-http-proxies create l7-ilb-proxy \
     --url-map=l7-ilb-map \
     --url-map-region=us-west1 \
     --region=us-west1 \
     --project=SERVICE_PROJECT_ID
   

   Bei HTTPS:

   Informationen zum Erstellen von SSL-Zertifikatsressourcen finden Sie unter SSL-Zertifikate. Von Google verwaltete Zertifikate werden derzeit nicht von internen Application Load Balancern unterstützt.

   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
   

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

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

   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-ilb-proxy \
     --url-map=l7-ilb-map \
     --region=us-west1 \
     --ssl-certificates=l7-ilb-cert \
     --project=SERVICE_PROJECT_ID
   

6. Erstellen Sie die Weiterleitungsregel.

   Bei benutzerdefinierten Netzwerken müssen Sie in der Weiterleitungsregel auf das Subnetz verweisen.

   Verwenden Sie lb-frontend-and-backend-subnet für die IP-Adresse der Weiterleitungsregel. Wenn Sie das Nur-Proxy-Subnetz verwenden, schlägt das Erstellen der Weiterleitungsregel fehl.

   Bei HTTP:

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

   gcloud compute forwarding-rules create l7-ilb-forwarding-rule \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=projects/HOST_PROJECT_ID/global/networks/lb-network \
     --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
     --address=IP_ADDRESS_NAME \
     --ports=80 \
     --region=us-west1 \
     --target-http-proxy=l7-ilb-proxy \
     --target-http-proxy-region=us-west1 \
     --project=SERVICE_PROJECT_ID
   

   Bei HTTPS:

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

   gcloud compute forwarding-rules create l7-ilb-forwarding-rule \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=projects/HOST_PROJECT_ID/global/networks/lb-network \
     --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
     --address=IP_ADDRESS_NAME \
     --ports=443 \
     --region=us-west1 \
     --target-https-proxy=l7-ilb-proxy \
     --target-https-proxy-region=us-west1 \
     --project=SERVICE_PROJECT_ID
   

Terraform

1. HTTP-Systemdiagnose definieren

   Bei HTTP:

   # health check
   resource "google_compute_health_check" "default" {
     name               = "l7-ilb-basic-check"
     provider           = google-beta
     project            = "my-service-project-id"
     timeout_sec        = 1
     check_interval_sec = 1
     http_health_check {
       port = "80"
     }
   }

   Bei HTTPS:

   # health check
   resource "google_compute_health_check" "default" {
     name               = "l7-ilb-basic-check"
     provider           = google-beta
     project            = "my-service-project-id"
     timeout_sec        = 1
     check_interval_sec = 1
     https_health_check {
       port = "443"
     }
   }

2. Backend-Dienst definieren

   # backend service
   resource "google_compute_region_backend_service" "default" {
     name                  = "l7-ilb-backend-service"
     provider              = google-beta
     project               = "my-service-project-id"
     region                = "us-west1"
     protocol              = "HTTP"
     load_balancing_scheme = "INTERNAL_MANAGED"
     timeout_sec           = 10
     health_checks         = [google_compute_health_check.default.id]
     backend {
       group           = google_compute_instance_group_manager.default.instance_group
       balancing_mode  = "UTILIZATION"
       capacity_scaler = 1.0
     }
   }

3. Erstellen Sie die URL-Zuordnung:

   # URL map
   resource "google_compute_region_url_map" "default" {
     name            = "l7-ilb-map"
     provider        = google-beta
     project         = "my-service-project-id"
     region          = "us-west1"
     default_service = google_compute_region_backend_service.default.id
   }

4. Erstellen Sie den Zielproxy.

   Bei HTTP:

   # HTTP target proxy
   resource "google_compute_region_target_http_proxy" "default" {
     name     = "l7-ilb-proxy"
     provider = google-beta
     project  = "my-service-project-id"
     region   = "us-west1"
     url_map  = google_compute_region_url_map.default.id
   }

   Für HTTPS: Erstellen Sie ein regionales SSL-Zertifikat.

   Informationen zum Erstellen von SSL-Zertifikatsressourcen finden Sie unter SSL-Zertifikate. Von Google verwaltete Zertifikate werden derzeit nicht von internen Application Load Balancern unterstützt.

   # Use self-signed SSL certificate
   resource "google_compute_region_ssl_certificate" "default" {
     name        = "l7-ilb-cert"
     provider    = google-beta
     project     = "my-service-project-id"
     region      = "us-west1"
     private_key = file("sample-private.key") # path to PEM-formatted file
     certificate = file("sample-server.cert") # path to PEM-formatted file
   }

   Mit dem regionalen SSL-Zertifikat einen Zielproxy erstellen

   # HTTPS target proxy
   resource "google_compute_region_target_https_proxy" "default" {
     name             = "l7-ilb-proxy"
     provider         = google-beta
     project          = "my-service-project-id"
     region           = "us-west1"
     url_map          = google_compute_region_url_map.default.id
     ssl_certificates = [google_compute_region_ssl_certificate.default.id]
   }

5. Erstellen Sie die Weiterleitungsregel.

   Bei benutzerdefinierten Netzwerken müssen Sie in der Weiterleitungsregel auf das Subnetz verweisen.

   Bei HTTP:

   # Forwarding rule
   resource "google_compute_forwarding_rule" "default" {
     name                  = "l7-ilb-forwarding-rule"
     provider              = google-beta
     project               = "my-service-project-id"
     region                = "us-west1"
     ip_protocol           = "TCP"
     port_range            = "80"
     load_balancing_scheme = "INTERNAL_MANAGED"
     target                = google_compute_region_target_http_proxy.default.id
     network               = google_compute_network.lb_network.id
     subnetwork            = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
     network_tier          = "PREMIUM"
     depends_on            = [google_compute_subnetwork.lb_frontend_and_backend_subnet]
   }

   Bei HTTPS:

   # Forwarding rule
   resource "google_compute_forwarding_rule" "default" {
     name                  = "l7-ilb-forwarding-rule"
     provider              = google-beta
     project               = "my-service-project-id"
     region                = "us-west1"
     ip_protocol           = "TCP"
     port_range            = "443"
     load_balancing_scheme = "INTERNAL_MANAGED"
     target                = google_compute_region_target_https_proxy.default.id
     network               = google_compute_network.lb_network.id
     subnetwork            = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
     network_tier          = "PREMIUM"
     depends_on            = [google_compute_subnetwork.lb_frontend_and_backend_subnet]
   }

Load-Balancer testen

Erstellen Sie zuerst eine Beispiel-Client-VM, um den Load-Balancer zu testen. Richten Sie dann eine SSH-Sitzung mit der VM ein und senden Sie Traffic von dieser VM zum Load-Balancer.

VM-Testinstanz erstellen

Clients können sich entweder im Hostprojekt oder in einem verbundenen Dienstprojekt befinden. In diesem Beispiel testen Sie die Funktion des Load-Balancers, indem Sie eine Client-VM in einem Dienstprojekt bereitstellen. Der Client muss dasselbe freigegebene VPC-Netzwerk verwenden und sich in derselben Region befinden wie der Load-Balancer.

Console

1. Rufen Sie in der Google Cloud Console die Seite VM-Instanzen auf.

   Zu Seite „VM-Instanzen“

2. Klicken Sie auf Instanz erstellen.

3. Legen Sie als Name client-vm fest.

4. Geben Sie als Zone us-west1-a an.

5. Klicken Sie auf Erweiterte Optionen und dann auf Netzwerk.

6. Geben Sie die folgenden Netzwerk-Tags ein: allow-ssh,load-balanced-backend.

7. Wählen Sie im Bereich Netzwerkschnittstellen die Option Für mich freigegebene Netzwerke (von Hostprojekt: HOST_PROJECT_ID) aus.

8. Wählen Sie das Subnetz lb-frontend-and-backend-subnet aus dem Netzwerk lb-network aus.

9. Klicken Sie auf Erstellen.

gcloud

Erstellen Sie eine VM-Testinstanz.

gcloud compute instances create client-vm \
    --image-family=debian-10 \
    --image-project=debian-cloud \
    --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
    --zone=us-west1-a \
    --tags=allow-ssh \
    --project=SERVICE_PROJECT_ID

Terraform

Erstellen Sie eine VM-Testinstanz.

resource "google_compute_instance" "vm_test" {
  name         = "client-vm"
  provider     = google-beta
  project      = "my-service-project-id"
  zone         = "us-west1-a"
  machine_type = "e2-small"
  tags         = ["allow-ssh"]
  network_interface {
    network    = google_compute_network.lb_network.id
    subnetwork = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
  }
  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-10"
    }
  }
  lifecycle {
    ignore_changes = [
      metadata["ssh-keys"]
    ]
  }
}

Traffic an den Load-Balancer senden

Stellen Sie mit SSH eine Verbindung zur soeben erstellten Instanz her und testen Sie, ob die HTTP(S)-Dienste auf den Backends über die IP-Adresse der Weiterleitungsregel des internen Application Load Balancers erreichbar sind und ob über die Backend-Instanzen hinweg Traffic ausgeglichen wird.

1. Stellen Sie eine SSH-Verbindung zur Clientinstanz her.

   gcloud compute ssh client-vm \
      --zone=us-west1-a
   

2. Prüfen Sie, ob die IP-Adresse ihren Hostnamen bereitstellt. Ersetzen Sie LB_IP_ADDRESS durch die IP-Adresse des Load-Balancers.

   curl LB_IP_ADDRESS
   

   Ersetzen Sie für HTTPS-Tests curl durch Folgendes:

   curl -k -s 'https://LB_IP_ADDRESS:443'
   

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

Load-Balancer mit einem projektübergreifenden Backend-Dienst konfigurieren

Das vorherige Beispiel auf dieser Seite zeigt, wie Sie die Bereitstellung einer freigegebenen VPC einrichten, bei der alle Load-Balancer-Komponenten und ihre Back-Ends im Dienstprojekt erstellt werden.

Mit internen Application Load Balancern können Sie auch Bereitstellungen freigegebener VPC-Netzwerke konfigurieren, bei denen eine URL-Zuordnung in einem Host- oder Dienstprojekt auf Backend-Dienste (und Backends) in mehreren Dienstprojekten in Umgebungen mit freigegebener VPC verweisen kann. Dies wird als projektübergreifender Dienstverweis bezeichnet.

Sie können die Schritte in diesem Abschnitt als Referenz verwenden, um alle hier aufgeführten unterstützten Kombinationen zu konfigurieren:

• Weiterleitungsregel, Ziel-Proxy und URL-Zuordnung im Hostprojekt und Backend-Dienst in einem Dienstprojekt
• Weiterleitungsregel, Ziel-Proxy und URL-Zuordnung in einem Dienstprojekt und Backend-Dienst in einem anderen Dienstprojekt

Der projektübergreifende Dienstverweis kann mit Instanzgruppen, serverlosen NEGs oder anderen unterstützten Backend-Typen verwendet werden. Wenn Sie serverlose NEGs verwenden, müssen Sie eine VM in dem VPC-Netzwerk erstellen, in dem Sie das Frontend des Load-Balancers erstellen möchten. Ein Beispiel finden Sie unter VM-Instanz in einem bestimmten Subnetz erstellen im Abschnitt Internen Application Load Balancer mit Cloud Run einrichten.

Anforderungen einrichten

In diesem Beispiel wird ein Beispiel-Load-Balancer mit seinem Frontend und Backend in zwei verschiedenen Dienstprojekten konfiguriert.

Wenn Sie es noch nicht getan haben, müssen Sie alle erforderlichen Schritte ausführen, um die freigegebene VPC einzurichten und das Netzwerk sowie die Subnetze und Firewallregeln zu konfigurieren, die für dieses Beispiel erforderlich sind. Weitere Informationen finden Sie hier:

• Berechtigungen
• Voraussetzungen

Abbildung 2. Load balancer frontend and backend in different service projects

Backends und Backend-Dienst in Dienstprojekt B erstellen

Alle Schritte in diesem Abschnitt müssen in Dienstprojekt B ausgeführt werden.

Console

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

   Zu Instanzvorlagen

   1. Klicken Sie auf Instanzvorlage erstellen.
   2. Geben Sie einen Namen für die Instanzvorlage ein: cross-ref-backend-template.
   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. Wenn Sie das Bootlaufwerk ändern müssen, klicken Sie auf Ändern.
      1. Wählen Sie als Betriebssystem die Option Debian aus.
      2. Wählen Sie für Version eines der verfügbaren Debian-Images aus, z. B. Debian GNU/Linux 10 (buster).
      3. Klicken Sie auf Auswählen.
   4. Klicken Sie auf Erweiterte Optionen und dann auf Netzwerk.
   5. Geben Sie die folgenden Netzwerk-Tags ein: allow-ssh,load-balanced-backend.
   6. Wählen Sie im Bereich Netzwerkschnittstellen die Option Für mich freigegebene Netzwerke (von Hostprojekt: HOST_PROJECT_ID) aus.
   7. Wählen Sie das Subnetz lb-frontend-and-backend-subnet aus dem Netzwerk lb-network aus.
   8. Klicken Sie auf Verwaltung. Fügen Sie unter Verwaltung das folgende Skript in das Feld Startskript 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
      

   9. 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 im Feld Name eine Bezeichnung für die Instanzgruppe ein: cross-ref-ig-backend.
   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 für Instanzvorlage die Option cross-ref-backend-template aus.

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

      Geben Sie für dieses Beispiel für 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.

3. Erstellen Sie einen regionalen Backend-Dienst. In diesem Schritt erstellen wir auch die Systemdiagnose und fügen dem Backend-Dienst Backends hinzu. Öffnen Sie in der Google Cloud Console die Seite Back-Ends.

   Zu Back-Ends

   1. Klicken Sie auf Regionalen Backend-Dienst erstellen.
   2. Geben Sie im Feld Name eine Bezeichnung für den Backend-Dienst ein: cross-ref-backend-service.
   3. Wählen Sie als Region us-west1 aus.
   4. Wählen Sie für Typ des Load Balancers die Option Regionaler interner Application Load Balancer (INTERNAL_MANAGED) aus.
   5. Setzen Sie den Backend-Typ auf Instanzgruppen.
   6. Legen Sie im Bereich Back-Ends für Netzwerk den Wert lb-network fest.
   7. Click Add backend and set the following fields:
      1. Legen Sie für die Instanzgruppe cross-ref-ig-backend fest.
      2. Geben Sie die Portnummern ein: 80.
      3. Setzen Sie den Balancing-Modus auf Auslastung.
      4. Klicken Sie auf Fertig.
   8. Wählen Sie im Abschnitt Systemdiagnose die Option Systemdiagnose erstellen mit den folgenden Parametern aus:
      1. Name: cross-ref-http-health-check
      2. Protokoll: HTTP
      3. Port: 80
      4. Klicken Sie auf Speichern.
   9. Klicken Sie auf Weiter.

   10. Optional: Geben Sie im Abschnitt Berechtigungen hinzufügen die IAM-Hauptkonten (normalerweise eine E-Mail-Adresse) von Load-Balancer-Administratoren aus anderen Projekten ein, damit sie diesen Backend-Dienst für Load-Balancern in ihren eigenen Projekten verwenden können. Ohne diese Berechtigung können Sie keinen projektübergreifenden Dienstverweis verwenden.

       Wenn Sie keine Berechtigung zum Festlegen von Zugriffssteuerungsrichtlinien für Backend-Dienste in diesem Projekt haben, können Sie den Backend-Dienst jetzt erstellen. Ein autorisierter Nutzer kann diesen Schritt später wie in der Gewähren Sie dem Load-Balancer-Administrator Berechtigungen zur Verwendung des Backend-Dienstes ausführen. In diesem Abschnitt wird auch beschrieben, wie Sie Zugriff auf alle Backend-Dienste in diesem Projekt gewähren, damit Sie nicht jedes Mal Zugriff gewähren müssen, wenn Sie einen neuen Backend-Dienst erstellen.

   11. Klicken Sie auf Erstellen.

gcloud

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

   gcloud compute instance-templates create BACKEND_IG_TEMPLATE \
       --region=us-west1 \
       --network=projects/HOST_PROJECT_ID/global/networks/lb-network \
       --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
       --tags=allow-ssh,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' \
       --project=SERVICE_PROJECT_B_ID
   

   Dabei gilt:

   • BACKEND_IG_TEMPLATE: Der Name der Instanzgruppenvorlage.
   • SERVICE_PROJECT_B_ID: Die Projekt-ID des Dienstprojekts B, in dem die Backends des Load-Balancers und der Backend-Dienst erstellt werden.
   • HOST_PROJECT_ID: Die Projekt-ID des freigegebenen VPC-Hostprojekts.

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

   gcloud compute instance-groups managed create BACKEND_MIG \
       --zone=us-west1-a \
       --size=2 \
       --template=BACKEND_IG_TEMPLATE \
       --project=SERVICE_PROJECT_B_ID
   

   Dabei gilt:

   • BACKEND_MIG: Der Name der Backend-Instanzgruppe.

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

   gcloud compute health-checks create http HTTP_HEALTH_CHECK_NAME \
     --region=us-west1 \
     --use-serving-port \
     --project=SERVICE_PROJECT_B_ID
   

   Dabei gilt:

   • HTTP_HEALTH_CHECK_NAME: Der Name für die HTTP-Systemdiagnose.

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

   gcloud compute backend-services create BACKEND_SERVICE_NAME \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --protocol=HTTP \
     --health-checks=HTTP_HEALTH_CHECK_NAME \
     --health-checks-region=us-west1 \
     --region=us-west1 \
     --project=SERVICE_PROJECT_B_ID
   

   Dabei gilt:

   • BACKEND_SERVICE_NAME: Der Name des Backend-Dienstes, der in Dienstprojekt B erstellt wurde.

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

   gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
     --balancing-mode=UTILIZATION \
     --instance-group=BACKEND_MIG \
     --instance-group-zone=us-west1-a \
     --region=us-west1 \
     --project=SERVICE_PROJECT_B_ID
   

Terraform

1. eine Instanzvorlage erstellen

   # Instance template
   resource "google_compute_instance_template" "default" {
     name     = "l7-ilb-backend-template"
     provider = google-beta
     project  = "my-service-project-b-id"
     region   = "us-west1"
     # For machine type, using small. For more options check https://cloud.google.com/compute/docs/machine-types
     machine_type = "e2-small"
     tags         = ["allow-ssh", "load-balanced-backend"]
     network_interface {
       network    = google_compute_network.lb_network.id
       subnetwork = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
       access_config {
         # add external ip to fetch packages like apache2, ssl
       }
     }
     disk {
       source_image = "debian-cloud/debian-10"
       auto_delete  = true
       boot         = true
     }
   
     # install apache2 and serve a simple web page
     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://metadata.google.internal/computeMetadata/v1/instance/name)"
       sudo echo "Page served from: $vm_hostname" | \
       tee /var/www/html/index.html
       sudo systemctl restart apache2
       EOF
     }
   }

2. Erstellen Sie eine verwaltete Instanzgruppe.

   Bei HTTP

   # MIG
   resource "google_compute_instance_group_manager" "default" {
     name               = "l7-ilb-backend-example"
     provider           = google-beta
     project            = "my-service-project-b-id"
     zone               = "us-west1-a"
     base_instance_name = "vm"
     target_size        = 2
     version {
       instance_template = google_compute_instance_template.default.id
       name              = "primary"
     }
     named_port {
       name = "http"
       port = 80
     }
   }

   Bei HTTPS

   # MIG
   resource "google_compute_instance_group_manager" "default" {
     name               = "l7-ilb-backend-example"
     provider           = google-beta
     project            = "my-service-project-b-id"
     zone               = "us-west1-a"
     base_instance_name = "vm"
     target_size        = 2
     version {
       instance_template = google_compute_instance_template.default.id
       name              = "primary"
     }
     named_port {
       name = "https"
       port = 443
     }
   }

3. Erstellen Sie eine Systemdiagnose für das Backend.

   Bei HTTP

   # health check
   resource "google_compute_health_check" "default" {
     name               = "l7-ilb-basic-check"
     provider           = google-beta
     project            = "my-service-project-b-id"
     timeout_sec        = 1
     check_interval_sec = 1
     http_health_check {
       port = "80"
     }
   }

   Bei HTTPS

   # health check
   resource "google_compute_health_check" "default" {
     name               = "l7-ilb-basic-check"
     provider           = google-beta
     project            = "my-service-project-b-id"
     timeout_sec        = 1
     check_interval_sec = 1
     https_health_check {
       port = "443"
     }
   }

4. Erstellen Sie einen regionalen Backend-Dienst.

   # backend service
   resource "google_compute_region_backend_service" "default" {
     name                  = "l7-ilb-backend-service"
     provider              = google-beta
     project               = "my-service-project-b-id"
     region                = "us-west1"
     protocol              = "HTTP"
     load_balancing_scheme = "INTERNAL_MANAGED"
     timeout_sec           = 10
     health_checks         = [google_compute_health_check.default.id]
     backend {
       group           = google_compute_instance_group_manager.default.instance_group
       balancing_mode  = "UTILIZATION"
       capacity_scaler = 1.0
     }
   }

Load-Balancer-Frontend und URL-Zuordnung in Dienstprojekt A erstellen

Alle Schritte in diesem Abschnitt müssen im Dienstprojekt A ausgeführt werden.

Console

Konfiguration starten

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

   Load-Balancing aufrufen

2. Klicken Sie auf Load-Balancer erstellen.
3. Wählen Sie unter Typ des Load Balancers die Option Application Load Balancer (HTTP/HTTPS) aus und klicken Sie auf Weiter.
4. Wählen Sie für Öffentlich oder intern die Option Intern aus und klicken Sie auf Weiter.
5. Wählen Sie für Regionenübergreifende oder 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 im Feld Name eine Bezeichnung für den Load-Balancer ein.
2. Wählen Sie us-west1 als Region aus.

3. Wählen Sie für das Netzwerk die Option lb-network (aus Projekt: HOST_PROJECT_NAME) aus.

   Wenn die Warnung Nur-Proxy-Subnetz im freigegebenen VPC-Netzwerk erforderlich angezeigt wird, prüfen Sie, ob der Administrator des Hostprojekts das proxy-only-subnet in der Region us-west1 im freigegebenen VPC-Netzwerk lb-network erstellt hat. Die Erstellung des Load-Balancers ist auch dann erfolgreich, wenn Sie keine Berechtigung zum Ansehen des Nur-Proxy-Subnetzes auf dieser Seite haben.

4. Lassen Sie das Fenster geöffnet, um fortzufahren.

Backend konfigurieren

1. Klicken Sie auf Backend-Konfiguration.
2. Klicken Sie auf Projektübergreifende Backend-Dienste.
3. Geben Sie als Projekt-ID die Projekt-ID für Dienstprojekt B ein.
4. Geben Sie unter Name des Backend-Dienstes den Namen des Backend-Dienstes aus Dienstprojekt B ein, das Sie verwenden möchten. In diesem Beispiel ist das cross-ref-backend-service.
5. Klicken Sie auf Backend-Dienst hinzufügen.

Routingregeln konfigurieren

• Klicken Sie auf Routingregeln. Der cross-ref-backend-service muss der einzige Backend-Dienst für alle nicht übereinstimmenden Hosts und alle nicht übereinstimmenden Pfade sein.

Weitere Informationen zur Trafficverwaltung finden Sie unter Trafficverwaltung einrichten.

Frontend konfigurieren

Damit der projektübergreifende Dienst verweist, muss das Frontend dasselbe Netzwerk (lb-network) aus dem freigegebenen VPC-Hostprojekt verwenden, mit dem der Backend-Dienst erstellt wurde.

Bei HTTP:

1. Klicken Sie auf Frontend-Konfiguration.
2. Geben Sie einen Name für die Weiterleitungsregel ein: cross-ref-http-forwarding-rule.
3. Legen Sie als Protokoll HTTP fest.
4. Setzen Sie die Option Subnetzwerk auf lb-frontend-and-backend-subnet. Wählen Sie nicht das Nur-Proxy-Subnetz für das Frontend aus, auch wenn es sich um eine Option in der Liste handelt.
5. Legen Sie als Port 80 fest.
6. Klicken Sie auf das Menü IP-Adresse und dann auf IP-Adresse erstellen.
7. Geben Sie im Bereich Statische interne IP-Adresse reservieren die folgenden Informationen an:
   1. Geben Sie im Feld Name cross-ref-ip-address ein.
   2. Klicken Sie unter Statische IP-Adresse auf Selbst auswählen. Geben Sie als Benutzerdefinierte IP-Adresse 10.1.2.98 ein.
   3. (Optional) Wenn Sie diese IP-Adresse für verschiedene Front-Ends freigeben möchten, setzen Sie den Zweck auf Freigegeben.
8. Klicken Sie auf Fertig.

Bei HTTPS:

Wenn Sie HTTPS zwischen dem Client und dem Load-Balancer verwenden, benötigen Sie eine oder mehrere SSL-Zertifikatsressourcen, um den Proxy zu konfigurieren. Informationen zum Erstellen von SSL-Zertifikatsressourcen finden Sie unter SSL-Zertifikate. Von Google verwaltete Zertifikate werden derzeit nicht von internen Application Load Balancern unterstützt.

1. Klicken Sie auf Frontend-Konfiguration.
2. Geben Sie einen Name für die Weiterleitungsregel ein: cross-ref-https-forwarding-rule.
3. Wählen Sie im Feld Protokoll die Option HTTPS (includes HTTP/2) aus.
4. Setzen Sie die Option Subnetzwerk auf lb-frontend-and-backend-subnet. Wählen Sie nicht das Nur-Proxy-Subnetz für das Frontend aus, auch wenn es sich um eine Option in der Liste handelt.
5. Achten Sie darauf, dass der Port auf 443 festgelegt ist, um HTTPS-Traffic zuzulassen.
6. Klicken Sie auf das Menü IP-Adresse und dann auf IP-Adresse erstellen.
7. Geben Sie im Bereich Statische interne IP-Adresse reservieren die folgenden Informationen an:
   1. Geben Sie im Feld Name cross-ref-ip-address ein.
   2. Klicken Sie unter Statische IP-Adresse auf Selbst auswählen. Geben Sie als Benutzerdefinierte IP-Adresse 10.1.2.98 ein.
   3. (Optional) Wenn Sie diese IP-Adresse für verschiedene Front-Ends freigeben möchten, setzen Sie den Zweck auf Freigegeben.
8. Klicken Sie auf die Liste Zertifikat.
   1. Wenn Sie bereits eine selbstverwaltete SSL-Zertifikatressource haben, die Sie als primäres SSL-Zertifikat verwenden möchten, wählen Sie es aus dem Menü aus.
   2. Wählen Sie andernfalls Neues Zertifikat erstellen aus.
      1. Geben Sie einen Namen für das SSL-Zertifikat ein.
      2. Laden Sie in den entsprechenden Feldern Ihre PEM-formatierten Dateien hoch:
         • Public-Key-Zertifikat
         • Zertifikatskette
         • Privater Schlüssel
      3. Klicken Sie auf Erstellen.
9. So fügen Sie zusätzlich zur primären SSL-Zertifikatsressource weitere Zertifikatsressourcen hinzu:
   1. Klicken Sie auf Zertifikat hinzufügen.
   2. Wählen Sie ein Zertifikat aus der Liste Zertifikate aus oder klicken Sie auf Neues Zertifikat erstellen und folgen Sie der vorherigen Anleitung.
10. Klicken Sie auf Fertig.

Konfiguration prüfen und fertigstellen

• Klicken Sie auf Erstellen.

Load-Balancer testen

Nachdem Sie den Load-Balancer erstellt haben, testen Sie ihn mithilfe der Schritte unter Load-Balancer testen.

gcloud

1. Erstellen Sie die URL-Zuordnung und legen Sie den Standarddienst auf den Backend-Dienst in Dienstprojekt B fest.

   gcloud compute url-maps create URL_MAP_NAME \
       --default-service=projects/SERVICE_PROJECT_B_ID/regions/us-west1/backendServices/BACKEND_SERVICE_NAME \
       --region=us-west1 \
       --project=SERVICE_PROJECT_A_ID
   

   Dabei gilt:

   • URL_MAP_NAME: Der Name für die URL-Zuordnung.
   • BACKEND_SERVICE_NAME: Der Name des Backend-Dienstes, der in Dienstprojekt B erstellt wurde.
   • SERVICE_PROJECT_B_ID: Die Projekt-ID des Dienstprojekts B, in dem die Backends und der Backend-Dienst des Load-Balancers erstellt werden.
   • SERVICE_PROJECT_A_ID ist die Projekt-ID des Dienstprojekts A, in dem das Frontend des Load-Balancers erstellt wird.

   Die Erstellung einer URL-Zuordnung schlägt fehl, wenn Sie die Berechtigung compute.backendServices.use für den Backend-Dienst in Dienstprojekt B nicht haben.

2. Erstellen Sie den Zielproxy.

   Bei HTTP:

   gcloud compute target-http-proxies create HTTP_TARGET_PROXY_NAME \
     --url-map=URL_MAP_NAME \
     --url-map-region=us-west1 \
     --region=us-west1 \
     --project=SERVICE_PROJECT_A_ID
   

   Dabei gilt:

   • HTTP_TARGET_PROXY_NAME: Der Name des HTTP-Ziel-Proxys.

   Bei HTTPS:

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

   gcloud compute ssl-certificates create SSL_CERTIFICATE_NAME \
     --certificate=PATH_TO_CERTIFICATE \
     --private-key=PATH_TO_PRIVATE_KEY \
     --region=us-west1 \
     --project=SERVICE_PROJECT_A_ID
   

   Dabei gilt:

   • SSL_CERTIFICATE_NAME: Der Name der SSL-Zertifikatsressource.
   • PATH_TO_CERTIFICATE: Der Pfad zur lokalen SSL-Zertifikatsdatei im PEM-Format.
   • PATH_TO_PRIVATE_KEY: Der Pfad zum privaten Schlüssel des lokalen SSL-Zertifikats im PEM-Format.

   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 HTTPS_TARGET_PROXY_NAME \
     --url-map=URL_MAP_NAME \
     --region=us-west1 \
     --ssl-certificates=SSL_CERTIFICATE_NAME \
     --project=SERVICE_PROJECT_A_ID
   

   Dabei gilt:

   • HTTPS_TARGET_PROXY_NAME: Der Name für den Ziel-HTTPS-Proxy.

3. Erstellen Sie die Weiterleitungsregel. Damit der projektübergreifende Dienst verweist, muss die Weiterleitungsregel dasselbe Netzwerk (lb-network) aus dem freigegebenen VPC-Hostprojekt verwenden, mit dem der Backend-Dienst erstellt wurde.

   Bei HTTP:

   gcloud compute forwarding-rules create HTTP_FORWARDING_RULE_NAME \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=projects/HOST_PROJECT_ID/global/networks/lb-network \
     --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
     --address=IP_ADDRESS_CROSS_REF \
     --ports=80 \
     --region=us-west1 \
     --target-http-proxy=HTTP_TARGET_PROXY_NAME \
     --target-http-proxy-region=us-west1 \
     --project=SERVICE_PROJECT_A_ID
   

   Dabei gilt:

   • HTTP_FORWARDING_RULE_NAME: Der Name der Weiterleitungsregel, die zur Verarbeitung von HTTP-Traffic verwendet wird.

   Bei HTTPS:

   gcloud compute forwarding-rules create HTTPS_FORWARDING_RULE_NAME \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=projects/HOST_PROJECT_ID/global/networks/lb-network \
     --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
     --address=IP_ADDRESS_CROSS_REF \
     --ports=443 \
     --region=us-west1 \
     --target-https-proxy=HTTPS_TARGET_PROXY_NAME \
     --target-https-proxy-region=us-west1 \
     --project=SERVICE_PROJECT_A_ID
   

   Dabei gilt:

   • HTTPS_FORWARDING_RULE_NAME: Der Name der Weiterleitungsregel, die für die Verarbeitung von HTTPS-Traffic verwendet wird.

4. Testen Sie den Load-Balancer mit den unter Load-Balancer testen beschriebenen Schritten.

Terraform

1. Erstellen Sie die URL-Zuordnung:

   # URL map
   resource "google_compute_region_url_map" "default" {
     name            = "l7-ilb-map"
     provider        = google-beta
     project         = "my-service-project-a-id"
     region          = "us-west1"
     default_service = google_compute_region_backend_service.default.id
   }

2. Erstellen Sie den Zielproxy.

   Bei HTTP

   # HTTP target proxy
   resource "google_compute_region_target_http_proxy" "default" {
     name     = "l7-ilb-proxy"
     provider = google-beta
     project  = "my-service-project-a-id"
     region   = "us-west1"
     url_map  = google_compute_region_url_map.default.id
   }

   Bei HTTPS

   Regionales SSL-Zertifikat erstellen

   # Use self-signed SSL certificate
   resource "google_compute_region_ssl_certificate" "default" {
     name        = "l7-ilb-cert"
     provider    = google-beta
     project     = "my-service-project-a-id"
     region      = "us-west1"
     private_key = file("sample-private.key") # path to PEM-formatted file
     certificate = file("sample-server.cert") # path to PEM-formatted file
   }

   Mit dem regionalen SSL-Zertifikat einen Zielproxy erstellen

   # HTTPS target proxy
   resource "google_compute_region_target_https_proxy" "default" {
     name             = "l7-ilb-proxy"
     provider         = google-beta
     project          = "my-service-project-a-id"
     region           = "us-west1"
     url_map          = google_compute_region_url_map.default.id
     ssl_certificates = [google_compute_region_ssl_certificate.default.id]
   }

3. Erstellen Sie die Weiterleitungsregel.

   Bei HTTP

   # Forwarding rule
   resource "google_compute_forwarding_rule" "default" {
     name                  = "l7-ilb-forwarding-rule"
     provider              = google-beta
     project               = "my-service-project-a-id"
     region                = "us-west1"
     ip_protocol           = "TCP"
     port_range            = "80"
     load_balancing_scheme = "INTERNAL_MANAGED"
     target                = google_compute_region_target_http_proxy.default.id
     network               = google_compute_network.lb_network.id
     subnetwork            = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
     network_tier          = "PREMIUM"
     depends_on            = [google_compute_subnetwork.lb_frontend_and_backend_subnet]
   }

   Bei HTTPS

   # Forwarding rule
   resource "google_compute_forwarding_rule" "default" {
     name                  = "l7-ilb-forwarding-rule"
     provider              = google-beta
     project               = "my-service-project-a-id"
     region                = "us-west1"
     ip_protocol           = "TCP"
     port_range            = "443"
     load_balancing_scheme = "INTERNAL_MANAGED"
     target                = google_compute_region_target_https_proxy.default.id
     network               = google_compute_network.lb_network.id
     subnetwork            = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
     network_tier          = "PREMIUM"
     depends_on            = [google_compute_subnetwork.lb_frontend_and_backend_subnet]
   }

4. Testen Sie den Load-Balancer mit den unter Load-Balancer testen beschriebenen Schritten.

Dem Load-Balancer-Administrator die Berechtigungen erteilen, den Backend-Dienst zu verwenden

Wenn Load-Balancer auf Backend-Dienste in anderen Dienstprojekten verweisen sollen, muss der Load-Balancer-Administrator die Berechtigung compute.backendServices.use haben. Um diese Berechtigung zu erteilen, können Sie die vordefinierte IAM-Rolle „Nutzer von Compute-Load-Balancer-Diensten“ (roles/compute.loadBalancerServiceUser) verwenden. Diese Rolle muss vom Dienstprojektadministrator gewährt werden und kann auf Projektebene oder auf der Ebene eines einzelnen Backend-Dienstes zugewiesen werden.

Dieser Schritt ist nicht erforderlich, wenn Sie beim Erstellen des Backend-Dienstes bereits die erforderlichen Berechtigungen auf Backend-Dienstebene gewährt haben. Sie können entweder diesen Abschnitt überspringen oder weiterlesen, um zu erfahren, wie Sie Zugriff auf alle Backend-Dienste in diesem Projekt gewähren, damit Sie nicht bei jedem Erstellen eines neuen Backend-Dienstes Zugriff gewähren müssen.

In diesem Beispiel muss ein Dienstprojektadministrator aus dem Dienstprojekt B genau einen der folgenden Befehle ausführen, um einem Load-Balancer-Administrator aus Dienstprojekt A die Berechtigung compute.backendServices.use zu erteilen. Dies kann entweder auf Projektebene (für alle Backend-Dienste im Projekt) oder pro Backend-Dienst erfolgen.

Console

Berechtigungen auf Projektebene

Gehen Sie folgendermaßen vor, um allen Backend-Diensten in Ihrem Projekt Berechtigungen zu erteilen.

Sie benötigen die Berechtigungen compute.regionBackendServices.setIamPolicy und resourcemanager.projects.setIamPolicy, um diesen Schritt auszuführen.

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

   Zu den Load-Balancing-Diensten

2. Wählen Sie im Abschnitt Alle Backend-Dienstberechtigungen (Berechtigungen auf Projektebene) Ihr Projekt aus.

3. Wenn das Feld "Berechtigungen" nicht sichtbar ist, klicken Sie auf Bereich "Berechtigungen" anzeigen. Der Bereich Berechtigungen auf Projektebene wird rechts geöffnet.

4. Klicken Sie auf Hauptkonto hinzufügen.

5. Geben Sie unter Neue Hauptkonten die E-Mail-Adresse oder die andere Kennung des Hauptkontos ein.

6. Wählen Sie unter Rolle die Rolle Nutzer von Compute-Load-Balancer-Diensten aus der Drop-down-Liste aus.

7. Optional: Fügen Sie der Rolle eine Bedingung hinzu.

8. Klicken Sie auf Speichern.

Berechtigungen auf Ressourcenebene für einzelne Backend-Dienste

Gehen Sie folgendermaßen vor, um einzelnen Backend-Diensten in Ihrem Projekt Berechtigungen zu erteilen.

Sie benötigen die Berechtigung compute.regionBackendServices.setIamPolicy, um diesen Schritt auszuführen.

gcloud

Berechtigungen auf Projektebene

Gehen Sie folgendermaßen vor, um allen Backend-Diensten in Ihrem Projekt Berechtigungen zu erteilen.

Sie benötigen die Berechtigungen compute.regionBackendServices.setIamPolicy und resourcemanager.projects.setIamPolicy, um diesen Schritt auszuführen.

gcloud projects add-iam-policy-binding SERVICE_PROJECT_B_ID \
    --member="user:LOAD_BALANCER_ADMIN" \
    --role="roles/compute.loadBalancerServiceUser"

Berechtigungen auf Ressourcenebene für einzelne Backend-Dienste

Auf Backend-Dienstebene können Dienstprojektadministratoren einen der folgenden Befehle verwenden, um die Rolle „Nutzer von Compute-Load-Balancer-Diensten“ (roles/compute.loadBalancerServiceUser) zuzuweisen.

Sie benötigen die Berechtigung compute.regionBackendServices.setIamPolicy, um diesen Schritt auszuführen.

gcloud projects add-iam-policy-binding SERVICE_PROJECT_B_ID \
    --member="user:LOAD_BALANCER_ADMIN" \
    --role="roles/compute.loadBalancerServiceUser" \
    --condition='expression=resource.name=="projects/SERVICE_PROJECT_B_ID/regions/us-west1/backend-services/BACKEND_SERVICE_NAME",title=Shared VPC condition'

oder

gcloud compute backend-services add-iam-policy-binding BACKEND_SERVICE_NAME \
    --member="user:LOAD_BALANCER_ADMIN" \
    --role="roles/compute.loadBalancerServiceUser" \
    --project=SERVICE_PROJECT_B_ID \
    --region=us-west1

Wenn Sie diese Befehle verwenden möchten, ersetzen Sie LOAD_BALANCER_ADMIN durch das Hauptkonto des Nutzers, z. B. [e-mail].

IAM-Berechtigungen können von Ihnen mithilfe von Bedingungen und durch Angabe von Bedingungsattributen auch so konfiguriert werden, dass sie nur für einen Teil der regionalen Backend-Dienste gelten.

Nächste Schritte

• Sie können mithilfe von Einschränkungen für Organisationsrichtlinien einschränken, wie Funktionen von freigegebenen VPCs wie die projektübergreifende Dienstreferenz in Ihrem Projekt verwendet werden. Weitere Informationen finden Sie unter Einschränkungen für Organisationsrichtlinien für Cloud Load Balancing.
• Informationen zum Verwalten der Nur-Proxy-Subnetzressource, die für interne Application Load Balancer erforderlich ist, finden Sie unter Nur-Proxy-Subnetz für interne Application Load Balancer.
• Informationen zum Beheben von Problemen mit einem internen Application Load Balancer finden Sie unter Fehlerbehebung bei internen Application Load Balancern.
• Einrichtung des Load-Balancers bereinigen