Internes TCP/UDP-Load-Balancing einrichten

Diese Anleitung vermittelt anhand eines Beispiels die Grundlagen des internen TCP/UDP-Load-Balancings von Google Cloud. Bevor Sie sie durchgehen, machen Sie sich mit folgenden Themen vertraut:

Berechtigungen

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

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

Weitere Informationen finden Sie in folgenden Leitfäden:

Einrichtung

In dieser Anleitung erfahren Sie, wie Sie einen internen TCP/UDP-Load-Balancer konfigurieren und testen. Die Schritte in diesem Abschnitt zeigen, wie Sie folgende Elemente konfigurieren:

  1. ein VPC-Netzwerk mit benutzerdefinierten Subnetzen als Beispiel
  2. Firewall-Regeln, die eingehende Verbindung zu Back-End-VMs ermöglichen
  3. Vier Back-End-VMs:
    • Zwei VMs in einer nicht verwalteten Instanzgruppe in Zone us-west1-a
    • Zwei VMs in einer nicht verwalteten Instanzgruppe in Zone us-west1-c
  4. Eine Client-VM zum Testen von Verbindungen
  5. Die folgenden Komponenten für den internen TCP/UDP-Load-Balancer:
    • Eine Systemdiagnose für den Back-End-Dienst
    • Einen internen Back-End-Dienst in der Region us-west1, um die Verteilung von Verbindungen zu den zwei zonalen Instanzgruppen zu verwalten
    • Eine interne Weiterleitungsregel und eine interne IP-Adresse für das Front-End des Load-Balancers

Die Architektur dieses Beispiels sieht folgendermaßen aus:

Beispielkonfiguration für internes TCP/UDP-Load-Balancing (zum Vergrößern klicken)
Beispielkonfiguration für internes TCP/UDP-Load-Balancing (zum Vergrößern klicken)

Netzwerk, Region und Subnetz konfigurieren

Der auf dieser Seite beschriebene interne TCP/UDP-Load-Balancer wird in einem VPC-Netzwerk im benutzerdefinierten Modus mit dem Namen lb-network erstellt.

Die Back-End-VMs und die Komponenten des Load-Balancers aus diesem Beispiel befinden sich in dieser Region und diesem Subnetz:

  • Region: us-west1
  • Subnetz: lb-subnet, mit primärem IP-Adressbereich 10.1.2.0/24

Zur Veranschaulichung des globalen Zugriffs wird in diesem Beispiel eine zweite Testclient-VM in einer anderen Region und einem anderen Subnetz erstellt:

  • Region: europe-west1
  • Subnetz: europe-subnet, mit primärem IP-Adressbereich 10.3.4.0/24

Gehen Sie so vor, um das Netzwerk und das Subnetz zu erstellen:

Console

  1. Rufen Sie in der Google Cloud Console die Seite „VPC-Netzwerke“ auf.
    Zur VPC-Netzwerkseite
  2. Klicken Sie auf VPC-Netzwerk erstellen.
  3. Geben Sie als 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: lb-subnet
      • Region: us-west1
      • IP-Adressbereich: 10.1.2.0/24
      • Klicken Sie auf Fertig.
    • Klicken Sie auf Subnetz hinzufügen und geben Sie die folgenden Informationen ein:
      • Name: europe-subnet
      • Region: europe-west1
      • IP-Adressbereich: 10.3.4.0/24
      • Klicken Sie auf Fertig.
  5. Klicken Sie auf Erstellen.

gcloud

  1. Erstellen Sie das benutzerdefinierte VPC-Netzwerk:

    gcloud compute networks create lb-network --subnet-mode=custom
    1. Erstellen Sie im Netzwerk lb-network ein Subnetz für Back-Ends in der Region us-west1 und ein anderes Subnetz zum Testen des globalen Zugriffs in der Region europe-west1:
    gcloud compute networks subnets create lb-subnet \
    --network=lb-network \
    --range=10.1.2.0/24 \
    --region=us-west1

    gcloud compute networks subnets create europe-subnet \
    --network=lb-network \
    --range=10.3.4.0/24 \
    --region=europe-west1

API

Stellen Sie eine POST-Anfrage an die Methode networks.insert.

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

{
  "routingConfig": {
    "routingMode": "REGIONAL"
  },
  "name": "lb-network",
  "autoCreateSubnetworks": false
}

Stellen Sie zwei POST-Anfragen an die Methode subnetworks.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks

{
  "name": "lb-subnet",
  "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
  "ipCidrRange": "10.1.2.0/24",
  "privateIpGoogleAccess": false
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/europe-west1/subnetworks

{
  "name": "europe-subnet",
  "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
   "ipCidrRange": "10.3.4.0/24",
   "privateIpGoogleAccess": false
}

Firewallregeln konfigurieren

Dieses Beispiel verwendet die folgenden Firewallregeln:

  • fw-allow-lb-access: Eine Eingangsregel, die für alle Ziele im VPC-Netzwerk gilt und Traffic von Quellen in den Bereichen 10.1.2.0/24 und 10.3.4.0/24 zulässt. Diese Regel lässt eingehenden Traffic von jedem Client zu, der sich in einem der beiden Subnetze befindet. Sie können damit später den globalen Zugriff konfigurieren und testen.

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

  • 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 allow-health-check verwendet, um die Instanzen zu identifizieren, auf die sie angewendet werden soll.

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

Console

  1. Rufen Sie in der Google Cloud Console die Seite „Firewallregeln“ auf.
    Zur Seite "Firewallregeln"
  2. Klicken Sie auf Firewallregel erstellen und geben Sie folgende Informationen ein, um die Regel zu erstellen, die Subnetztraffic zulässt:
    • Name: fw-allow-lb-access
    • Netzwerk: lb-network
    • Priorität: 1000
    • Trafficrichtung: Eingehend
    • Aktion bei Übereinstimmung: Zulassen
    • Ziele: Alle Instanzen im Netzwerk
    • Quellfilter: IP ranges
    • Quell-IP-Bereiche: 10.1.2.0/24 und 10.3.4.0/24
    • Protokolle und Ports: Alle zulassen
  3. Klicken Sie auf Erstellen.
  4. Klicken Sie noch einmal auf Firewallregel erstellen, um die Regel zu erstellen, die eingehende SSH-Verbindungen zulässt:
    • Name: fw-allow-ssh
    • Netzwerk: lb-network
    • Priorität: 1000
    • Trafficrichtung: Eingehend
    • Aktion bei Übereinstimmung: Zulassen
    • Ziele: Angegebene Ziel-Tags
    • Ziel-Tags: allow-ssh
    • Quellfilter: IP ranges
    • Quell-IP-Bereiche: 0.0.0.0/0
    • Protokolle und Ports: Wählen Sie Angegebene Protokolle und Ports aus und geben Sie Folgendes ein: tcp:22
  5. Klicken Sie auf Erstellen.
  6. Klicken Sie ein drittes Mal auf Firewallregel erstellen, um die Regel zum Zulassen von Google Cloud-Systemdiagnosen zu erstellen:
    • Name: fw-allow-health-check
    • Netzwerk: lb-network
    • Priorität: 1000
    • Trafficrichtung: Eingehend
    • Aktion bei Übereinstimmung: Zulassen
    • Ziele: Angegebene Ziel-Tags
    • Ziel-Tags: allow-health-check
    • Quellfilter: IP ranges
    • Quell-IP-Bereiche: 130.211.0.0/22 und 35.191.0.0/16
    • Protokolle und Ports: Alle zulassen
  7. Klicken Sie auf Erstellen.

gcloud

  1. Erstellen Sie die Firewallregel fw-allow-lb-access, um die Kommunikation mit dem Subnetz zuzulassen:

    gcloud compute firewall-rules create fw-allow-lb-access \
    --network=lb-network \
    --action=allow \
    --direction=ingress \
    --source-ranges=10.1.2.0/24,10.3.4.0/24 \
    --rules=tcp,udp,icmp

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

  3. Erstellen Sie die Regel fw-allow-health-check, um Google Cloud-Systemdiagnosen zuzulassen.

    gcloud compute firewall-rules create fw-allow-health-check \
    --network=lb-network \
    --action=allow \
    --direction=ingress \
    --target-tags=allow-health-check \
    --source-ranges=130.211.0.0/22,35.191.0.0/16 \
    --rules=tcp,udp,icmp

API

Erstellen Sie die Firewallregel fw-allow-lb-access. Stellen Sie dazu eine POST-Anfrage an die Methode firewalls.insert.

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

{
  "name": "fw-allow-lb-access",
  "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
  "priority": 1000,
  "sourceRanges": [
    "10.1.2.0/24", "10.3.4.0/24"
  ],
  "allowed": [
    {
      "IPProtocol": "tcp"
    },
    {
      "IPProtocol": "udp"
    },
    {
      "IPProtocol": "icmp"
    }
  ],
  "direction": "INGRESS",
  "logConfig": {
    "enable": false
  },
  "disabled": false
}

Erstellen Sie die Firewallregel fw-allow-ssh. Stellen Sie dazu eine POST-Anfrage an die Methode firewalls.insert.

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

{
  "name": "fw-allow-ssh",
       "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
  "priority": 1000,
  "sourceRanges": [
    "0.0.0.0/0"
  ],
  "targetTags": [
    "allow-ssh"
  ],
  "allowed": [
   {
     "IPProtocol": "tcp",
     "ports": [
       "22"
     ]
   }
  ],
 "direction": "INGRESS",
 "logConfig": {
   "enable": false
 },
 "disabled": false
}

Erstellen Sie die Firewallregel fw-allow-health-check. Stellen Sie dazu eine POST-Anfrage an die Methode firewalls.insert.

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

{
  "name": "fw-allow-health-check",
  "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
  "priority": 1000,
  "sourceRanges": [
    "130.211.0.0/22",
    "35.191.0.0/16"
  ],
  "targetTags": [
    "allow-health-check"
  ],
  "allowed": [
    {
      "IPProtocol": "tcp"
    },
    {
      "IPProtocol": "udp"
    },
    {
      "IPProtocol": "icmp"
    }
  ],
  "direction": "INGRESS",
  "logConfig": {
    "enable": false
  },
  "disabled": false
}

Back-End-VMs und Instanzgruppen erstellen

In diesem Beispiel werden zwei nicht verwaltete Instanzgruppen mit jeweils zwei Back-End-VMs (Server) verwendet. Die beiden Instanzgruppen befinden sich dabei in den separaten Zonen us-west1-a und us-west1-c, um den regionalen Charakter des internen TCP/UDP-Load-Balancings zu veranschaulichen.

  • Die Instanzgruppe ig-a enthält diese beiden VMs:
    • vm-a1
    • vm-a2
  • Die Instanzgruppe ig-c enthält diese beiden VMs:
    • vm-c1
    • vm-c2

Auf den Traffic zu allen vier Back-End-VMs wird Load-Balancing angewendet.

Zur Illustration dieses Beispiels und der zusätzlichen Konfigurationsoptionen führt jede der vier VMs einen Apache-Webserver aus, der die folgenden TCP-Ports überwacht: 80, 8008, 8080, 8088, 443 und 8443.

Jeder VM wird eine interne IP-Adresse im lb-subnet und eine sitzungsspezifische externe (öffentliche) IP-Adresse zugewiesen. Sie können die externen IP-Adressen später entfernen.

Externe IP-Adressen für die Back-End-VMs sind nicht erforderlich. In diesem Beispiel sind sie aber praktisch, weil die Back-End-VMs auf diese Weise Apache aus dem Internet herunterladen können. Außerdem vereinfachen sie die Verbindung über SSH.

Standardmäßig ist Apache so konfiguriert, dass eine Bindung an eine beliebige IP-Adresse erfolgt. Interne TCP/UDP-Load-Balancer stellen Pakete unter Übernahme der Ziel-IP-Adresse bereit. Achten Sie deshalb darauf, dass die auf den Back-End-VMs ausgeführte Serversoftware die IP-Adresse der internen Weiterleitungsregel des Load-Balancers überwacht. Wenn Sie mehrere interne Weiterleitungsregeln konfigurieren, achten Sie darauf, dass die Software die jeweils zugewiesene interne IP-Adresse überwacht. Die Ziel-IP-Adresse eines Pakets, das ein interner TCP/UDP-Load-Balancer an eine Back-End-VM liefert, ist die interne IP-Adresse der Weiterleitungsregel.

Der Einfachheit halber wird auf diesen Back-End-VMs Debian GNU/Linux 10 ausgeführt.

Console

Back-End-VMs erstellen

  1. Rufen Sie in der Google Cloud Console die Seite „VM-Instanzen” auf.
    Zur Seite "VM-Instanzen"
  2. Wiederholen Sie die nachstehenden Schritte, um vier VMs mit den folgenden Kombinationen aus Name und Zone zu erstellen.
    • Name: vm-a1, Zone: us-west1-a
    • Name: vm-a2, Zone: us-west1-a
    • Name: vm-c1, Zone: us-west1-c
    • Name: vm-c2, Zone: us-west1-c
  3. Klicken Sie auf Instanz erstellen.
  4. Legen Sie den Namen wie in Schritt 2 angegeben fest.
  5. Wählen Sie für die Region us-west1 aus und legen Sie die Zone wie in Schritt 2 angegeben fest.
  6. Achten Sie im Bereich Bootlaufwerk darauf, dass als Bootlaufwerk-Optionen das Betriebssystem Debian und die Version 10 (Buster) ausgewählt sind. Klicken Sie auf Auswählen, um das Image bei Bedarf zu ändern.

  7. Klicken Sie auf Verwaltung, Sicherheit, Laufwerke, Netzwerke, einzelne Mandanten und nehmen Sie die folgenden Änderungen vor:

    • Klicken Sie auf Netzwerke und fügen Sie die folgenden Netzwerk-Tags hinzu: allow-ssh und allow-health-check.
    • Klicken Sie unter Netzwerkschnittstellen auf Bearbeiten , nehmen Sie die folgenden Änderungen vor und klicken Sie dann auf Fertig:
      • Netzwerk: lb-network
      • Subnetz: lb-subnet
      • Primäre interne IP: flüchtig (automatisch)
      • Externe IP: sitzungsspezifisch

    • Klicken Sie auf Verwaltung. Kopieren Sie den folgenden Skriptinhalt und fügen Sie ihn im Feld Startskript ein. Der Skriptinhalt ist für alle vier VMs gleich:

      #! /bin/bash
if [ -f /etc/startup_script_completed ]; then
exit 0
fi
apt-get update
apt-get install apache2 -y
a2ensite default-ssl
a2enmod ssl
file_ports="/etc/apache2/ports.conf"
file_http_site="/etc/apache2/sites-available/000-default.conf"
file_https_site="/etc/apache2/sites-available/default-ssl.conf"
http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
http_vh_prts="*:80 *:8008 *:8080 *:8088"
https_listen_prts="Listen 443\nListen 8443"
https_vh_prts="*:443 *:8443"
vm_hostname="$(curl -H "Metadata-Flavor:Google" \
http://169.254.169.254/computeMetadata/v1/instance/name)"
echo "Page served from: $vm_hostname" | \
tee /var/www/html/index.html
echo "Page served from: $vm_hostname" | \
tee /var/www/html/index.html
prt_conf="$(cat "$file_ports")"
prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
echo "$prt_conf" | tee "$file_ports"
http_site_conf="$(cat "$file_http_site")"
http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
echo "$http_site_conf_2" | tee "$file_http_site"
https_site_conf="$(cat "$file_https_site")"
https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
echo "$https_site_conf_2" | tee "$file_https_site"
systemctl restart apache2
touch /etc/startup_script_completed

  8. Klicken Sie auf Erstellen.

Instanzgruppen erstellen

  1. Öffnen Sie in der Google Cloud Console die Seite "Instanzgruppen".
    Zur Seite "Instanzgruppen"
  2. Wiederholen Sie die folgenden Schritte, um mit diesen Kombinationen zwei nicht verwaltete Instanzgruppen mit jeweils zwei VMs zu erstellen.
    • Instanzgruppe: ig-a, Zone: us-west1-a, VMs: vm-a1 und vm-a2
    • Instanzgruppe: ig-c, Zone: us-west1-c, VMs: vm-c1 und vm-c2
  3. Klicken Sie auf Instanzgruppe erstellen.
  4. Klicken Sie auf Neue nicht verwaltete Instanzgruppe.
  5. Legen Sie Name wie in Schritt 2 angegeben fest.
  6. Wählen Sie im Bereich Standort als Region us-west1 aus und legen Sie dann wie in Schritt 2 angegeben eine Zone fest.
  7. Geben Sie bei Netzwerk den Parameter lb-network ein.
  8. Geben Sie bei Subnetzwerk den Parameter lb-subnet ein.
  9. Fügen Sie im Bereich VM-Instanzen die in Schritt 2 angegebenen VMs hinzu.
  10. Klicken Sie auf Erstellen.

gcloud

  1. Erstellen Sie die vier VMs, indem Sie den folgenden Befehl viermal ausführen und die nachstehenden vier Kombinationen für [VM-NAME] und [ZONE] verwenden. Der Skriptinhalt ist für alle vier VMs identisch.

    • [VM-NAME]: vm-a1; [ZONE]: us-west1-a
    • [VM-NAME]: vm-a2; [ZONE]: us-west1-a
    • [VM-NAME]: vm-c1; [ZONE]: us-west1-c
    • [VM-NAME]: vm-c2; [ZONE]: us-west1-c
    gcloud compute instances create [VM-NAME] \
    --zone=[ZONE] \
    --image-family=debian-10 \
    --image-project=debian-cloud \
    --tags=allow-ssh,allow-health-check \
    --subnet=lb-subnet \
    --metadata=startup-script='#! /bin/bash
if [ -f /etc/startup_script_completed ]; then
exit 0
fi
apt-get update
apt-get install apache2 -y
a2ensite default-ssl
a2enmod ssl
file_ports="/etc/apache2/ports.conf"
file_http_site="/etc/apache2/sites-available/000-default.conf"
file_https_site="/etc/apache2/sites-available/default-ssl.conf"
http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
http_vh_prts="*:80 *:8008 *:8080 *:8088"
https_listen_prts="Listen 443\nListen 8443"
https_vh_prts="*:443 *:8443"
vm_hostname="$(curl -H "Metadata-Flavor:Google" \
http://169.254.169.254/computeMetadata/v1/instance/name)"
echo "Page served from: $vm_hostname" | \
tee /var/www/html/index.html
prt_conf="$(cat "$file_ports")"
prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
echo "$prt_conf" | tee "$file_ports"
http_site_conf="$(cat "$file_http_site")"
http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
echo "$http_site_conf_2" | tee "$file_http_site"
https_site_conf="$(cat "$file_https_site")"
https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
echo "$https_site_conf_2" | tee "$file_https_site"
systemctl restart apache2
touch /etc/startup_script_completed'

  2. Erstellen Sie die zwei nicht verwalteten Instanzgruppen in jeder Zone:

    gcloud compute instance-groups unmanaged create ig-a \
    --zone=us-west1-a
gcloud compute instance-groups unmanaged create ig-c \
    --zone=us-west1-c

  3. Fügen Sie den entsprechenden Instanzgruppen die VMs hinzu:

    gcloud compute instance-groups unmanaged add-instances ig-a \
    --zone=us-west1-a \
    --instances=vm-a1,vm-a2
gcloud compute instance-groups unmanaged add-instances ig-c \
    --zone=us-west1-c \
    --instances=vm-c1,vm-c2

API

Verwenden Sie für die vier VMs die folgenden VM-Namen und -Zonen:

  • [VM-NAME]: vm-a1; [ZONE]: us-west1-a
  • [VM-NAME]: vm-a2; [ZONE]: us-west1-a
  • [VM-NAME]: vm-c1; [ZONE]: us-west1-c
  • [VM-NAME]: vm-c2; [ZONE]: us-west1-c

Sie können den aktuellen DEBIAN_IMAGE_NAME abrufen, indem Sie den folgenden gcloud-Befehl ausführen:

gcloud compute images list \
 --filter="family=debian-10"

Erstellen Sie jetzt vier Back-End-VMs. Stellen Sie dazu vier POST-Anfragen an die Methode instances.insert:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/[ZONE]/instances

{
  "name": "[VM-NAME]",
  "tags": {
    "items": [
      "allow-health-check",
      "allow-ssh"
    ]
  },
  "machineType": "https://www.googleapis.com/compute/v1/projects/project-id/zones/[ZONE]/machineTypes/e2-standard-2",
  "canIpForward": false,
  "networkInterfaces": [
    {
      "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
      "subnetwork": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/subnetworks/lb-subnet",
      "accessConfigs": [
        {
          "type": "ONE_TO_ONE_NAT",
          "name": "external-nat",
          "networkTier": "PREMIUM"
        }
      ]
    }
  ],
  "disks": [
    {
      "type": "PERSISTENT",
      "boot": true,
      "mode": "READ_WRITE",
      "autoDelete": true,
      "deviceName": "[VM-NAME]",
      "initializeParams": {
        "sourceImage": "projects/debian-cloud/global/images/debian-image-name",
        "diskType": "projects/project-id/zones/zone/diskTypes/pd-standard",
        "diskSizeGb": "10"
      }
    }
  ],
  "metadata": {
    "items": [
      {
        "key": "startup-script",
        "value": "#! /bin/bash\napt-get update\napt-get install apache2 -y\na2ensite default-ssl\na2enmod ssl\nfile_ports=\"/etc/apache2/ports.conf\"\nfile_http_site=\"/etc/apache2/sites-available/000-default.conf\"\nfile_https_site=\"/etc/apache2/sites-available/default-ssl.conf\"\nhttp_listen_prts=\"Listen 80\\nListen 8008\\nListen 8080\\nListen 8088\"\nhttp_vh_prts=\"*:80 *:8008 *:8080 *:8088\"\nhttps_listen_prts=\"Listen 443\\nListen 8443\"\nhttps_vh_prts=\"*:443 *:8443\"\nvm_hostname=\"$(curl -H \"Metadata-Flavor:Google\" \\\nhttp://169.254.169.254/computeMetadata/v1/instance/name)\"\necho \"Page served from: $vm_hostname\" | \\\ntee /var/www/html/index.html\nprt_conf=\"$(cat \"$file_ports\")\"\nprt_conf_2=\"$(echo \"$prt_conf\" | sed \"s|Listen 80|${http_listen_prts}|\")\"\nprt_conf=\"$(echo \"$prt_conf_2\" | sed \"s|Listen 443|${https_listen_prts}|\")\"\necho \"$prt_conf\" | tee \"$file_ports\"\nhttp_site_conf=\"$(cat \"$file_http_site\")\"\nhttp_site_conf_2=\"$(echo \"$http_site_conf\" | sed \"s|*:80|${http_vh_prts}|\")\"\necho \"$http_site_conf_2\" | tee \"$file_http_site\"\nhttps_site_conf=\"$(cat \"$file_https_site\")\"\nhttps_site_conf_2=\"$(echo \"$https_site_conf\" | sed \"s|_default_:443|${https_vh_prts}|\")\"\necho \"$https_site_conf_2\" | tee \"$file_https_site\"\nsystemctl restart apache2"
      }
    ]
  },
  "scheduling": {
    "preemptible": false
  },
  "deletionProtection": false
}

Erstellen Sie nun zwei Instanzgruppen. Stellen Sie dazu eine POST-Anfrage an die Methode instanceGroups.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups

{
  "name": "ig-a",
  "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
  "subnetwork": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/subnetworks/lb-subnet"
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instanceGroups

{
  "name": "ig-c",
  "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
  "subnetwork": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/subnetworks/lb-subnet"
}

Fügen Sie jeder Instanzgruppe Instanzen hinzu. Stellen Sie dazu eine POST-Anfrage an die Methode instanceGroups.addInstances.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a/addInstances

{
  "instances": [
    {
      "instance": "https://www.googleapis.com/compute/v1/projects/project-id/zones/us-west1-a/instances/vm-a1",
      "instance": "https://www.googleapis.com/compute/v1/projects/project-id/zones/us-west1-a/instances/vm-a2"
    }
  ]
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instanceGroups/ig-c/addInstances

{
  "instances": [
    {
      "instance": "https://www.googleapis.com/compute/v1/projects/project-id/zones/us-west1-c/instances/vm-c1",
      "instance": "https://www.googleapis.com/compute/v1/projects/project-id/zones/us-west1-c/instances/vm-c2"
    }
  ]
}

Client-VM erstellen

In diesem Beispiel wird eine Client-VM (vm-client) erstellt, die sich in derselben Region wie die Back-End-VMs (Server) befindet. Der Client validiert die Konfiguration des Load-Balancers und demonstriert das erwartete Verhalten, wie im Abschnitt "Test" beschrieben.

Console

  1. Rufen Sie in der Google Cloud Console die Seite „VM-Instanzen” auf.
    Zur Seite „VM-Instanzen”
  2. Klicken Sie auf Instanz erstellen.
  3. Legen Sie als Name vm-client fest.
  4. Setzen Sie Zone auf us-west1-a.
  5. Klicken Sie auf Verwaltung, Sicherheit, Laufwerke, Netzwerke, einzelne Mandanten und nehmen Sie die folgenden Änderungen vor:
    • Klicken Sie auf Vernetzung und fügen Sie allow-ssh an die Netzwerk-Tags hinzu.
    • Klicken Sie unter Netzwerkschnittstellen auf die Schaltfläche "Bearbeiten", nehmen Sie die folgenden Änderungen vor und klicken Sie auf Fertig:
      • Netzwerk: lb-network
      • Subnetz: lb-subnet
      • Primäre interne IP: flüchtig (automatisch)
      • Externe IP: sitzungsspezifisch
  6. Klicken Sie auf Erstellen.

gcloud

Die Client-VM kann sich in einer beliebigen Zone in derselben Region wie der Load-Balancer befinden. Außerdem kann sie jedes Subnetz in dieser Region verwenden. In diesem Beispiel befindet sich der Client in der Zone us-west1-a und verwendet dasselbe Subnetz wie die Back-End-VMs.

gcloud compute instances create vm-client \
    --zone=us-west1-a \
    --image-family=debian-10 \
    --image-project=debian-cloud \
    --tags=allow-ssh \
    --subnet=lb-subnet

API

Stellen Sie eine POST-Anfrage an die Methode instances.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances

{
  "name": "vm-client",
  "tags": {
    "items": [
      "allow-ssh"
    ]
  },
  "machineType": "https://www.googleapis.com/compute/v1/projects/project-id/zones/us-west1-a/machineTypes/e2-standard-2",
  "canIpForward": false,
  "networkInterfaces": [
    {
      "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
      "subnetwork": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/subnetworks/lb-subnet",
      "accessConfigs": [
        {
          "type": "ONE_TO_ONE_NAT",
          "name": "external-nat",
          "networkTier": "PREMIUM"
        }
      ]
    }
  ],
  "disks": [
    {
      "type": "PERSISTENT",
      "boot": true,
      "mode": "READ_WRITE",
      "autoDelete": true,
      "deviceName": "vm-client",
      "initializeParams": {
        "sourceImage": "projects/debian-cloud/global/images/debian-image-name",
        "diskType": "projects/project-id/zones/us-west1-a/diskTypes/pd-standard",
        "diskSizeGb": "10"
      }
    }
  ],
  "scheduling": {
    "preemptible": false
  },
  "deletionProtection": false
}

Komponenten für den Load-Balancer konfigurieren

In diesen Schritten konfigurieren Sie alle Komponenten für den internen TCP/UDP-Load-Balancer. Zuerst konfigurieren Sie die Systemdiagnose und den Back-End-Dienst und danach die Front-End-Komponenten:

  • Systemdiagnose: In diesem Beispiel wird eine HTTP-Systemdiagnose verwendet, die lediglich auf die HTTP-Antwort 200 (OK) prüft. Weitere Informationen finden Sie im Abschnitt "Systemdiagnose" der Übersicht über das interne TCP/UDP-Load-Balancing.

  • Back-End-Dienst: Da der HTTP-Traffic über den internen Load-Balancer weitergeleitet werden muss, müssen Sie TCP und nicht UDP verwenden.

  • Weiterleitungsregel: Dieses Beispiel erstellt eine einzelne interne Weiterleitungsregel.

  • Interne IP-Adresse: In diesem Beispiel wird bei der Erstellung der Weiterleitungsregel eine interne IP-Adresse (10.1.2.99) festgelegt.

Console

Load-Balancer erstellen und Back-End-Dienst konfigurieren

  1. Öffnen Sie in der Google Cloud Console die Seite "Load-Balancing".
    Zur Seite "Load-Balancing"
  2. Klicken Sie auf Load-Balancer erstellen.
  3. Klicken Sie unter TCP-Load-Balancing auf Konfiguration starten.
  4. Wählen Sie unter Internet oder nur intern die Option Nur zwischen meinen VMs aus.
  5. Klicken Sie auf Weiter.
  6. Legen Sie als Name be-ilb fest.
  7. Klicken Sie auf Back-End-Konfiguration und nehmen Sie folgende Änderungen vor:
    1. Region: us-west1
    2. Netzwerk: lb-network
    3. Wählen Sie unter Back-Ends im Bereich Neues Element die Instanzgruppe ig-a aus und klicken Sie auf Fertig.
    4. Klicken Sie auf Back-End hinzufügen. Wählen Sie im angezeigten Bereich Neues Element die Instanzgruppe ig-c aus und klicken Sie noch einmal auf Fertig.
    5. Wählen Sie unter Systemdiagnose die Option Weitere Systemdiagnose erstellen aus, geben Sie die folgenden Informationen ein und klicken Sie auf Speichern und fortfahren:
      • Name: hc-http-80
      • Protokoll: HTTP
      • Port: 80
      • Proxyprotokoll: NONE
      • Anfragepfad: / Wenn Sie die Cloud Console zum Erstellen des Load-Balancers verwenden, ist die Systemdiagnose global. Wenn Sie eine regionale Systemdiagnose erstellen möchten, verwenden Sie gcloud oder die API.
    6. Prüfen Sie, bevor Sie fortfahren, ob sich neben Back-End-Konfiguration ein blaues Häkchen befindet. Gehen Sie diesen Schritt noch einmal durch, wenn nicht.
  8. Klicken Sie auf Front-End-Konfiguration. Nehmen Sie im Bereich Neue Front-End-IP-Adresse und neuer Front-End-Port die folgenden Änderungen vor:
    1. Name: fr-ilb
    2. Subnetzwerk: lb-subnet
    3. Wählen Sie unter Interne IP-Adresse die Option Statische interne IP-Adresse reservieren aus, geben Sie die folgenden Informationen ein und klicken Sie dann auf Reservieren:
      • Name: ip-ilb
      • Statische IP-Adresse: Selbst auswählen
      • Benutzerdefinierte IP-Adresse: 10.1.2.99
    4. Ports: Wählen Sie Mehrere aus und geben Sie 80,8008,8080,8088 als Portnummer ein.
    5. Überprüfen Sie, bevor Sie fortfahren, ob sich neben der Front-End-Konfiguration ein blaues Häkchen befindet. Gehen Sie diesen Schritt noch einmal durch, wenn nicht.
  9. Klicken Sie auf Prüfen und abschließen. Kontrollieren Sie die Einstellungen.
  10. Klicken Sie auf Erstellen.

gcloud

  1. Erstellen Sie eine neue regionale HTTP-Systemdiagnose, um die HTTP-Verbindung zu den VMs auf 80 zu testen.

    gcloud compute health-checks create http hc-http-80 \
    --region=us-west1 \
    --port=80

  2. Erstellen Sie den Back-End-Dienst für HTTP-Traffic:

    gcloud compute backend-services create be-ilb \
    --load-balancing-scheme=internal \
    --protocol=tcp \
    --region=us-west1 \
    --health-checks=hc-http-80 \
    --health-checks-region=us-west1

  3. Fügen Sie dem Back-End-Dienst die beiden Instanzgruppen hinzu:

    gcloud compute backend-services add-backend be-ilb \
    --region=us-west1 \
    --instance-group=ig-a \
    --instance-group-zone=us-west1-a
gcloud compute backend-services add-backend be-ilb \
    --region=us-west1 \
    --instance-group=ig-c \
    --instance-group-zone=us-west1-c

  4. Erstellen Sie eine Weiterleitungsregel für den Back-End-Dienst. Wenn Sie die Weiterleitungsregel erstellen, geben Sie für die interne IP-Adresse im Subnetz den Wert 10.1.2.99 an.

    gcloud compute forwarding-rules create fr-ilb \
    --region=us-west1 \
    --load-balancing-scheme=internal \
    --network=lb-network \
    --subnet=lb-subnet \
    --address=10.1.2.99 \
    --ip-protocol=TCP \
    --ports=80,8008,8080,8088 \
    --backend-service=be-ilb \
    --backend-service-region=us-west1

API

Erstellen Sie die Systemdiagnose. Stellen Sie dazu eine POST-Anfrage an die Methode regionHealthChecks.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/regionHealthChecks

{
  "name": "hc-http-80",
  "type": "HTTP",
  "httpHealthCheck": {
    "port": 80
  }
}

Erstellen Sie den regionalen Back-End-Dienst. Stellen Sie dazu eine POST-Anfrage an die Methode regionBackendServices.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices

{
  "name": "be-ilb",
  "backends": [
    {
      "group": "https://www.googleapis.com/compute/v1/projects/project-id/zones/us-west1-a/instanceGroups/ig-a",
      "balancingMode": "CONNECTION"
    },
    {
      "group": "https://www.googleapis.com/compute/v1/projects/project-id/zones/us-west1-c/instanceGroups/ig-c",
      "balancingMode": "CONNECTION"
    }
  ],
  "healthChecks": [
    "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/healthChecks/hc-http-80"
  ],
  "loadBalancingScheme": "INTERNAL",
  "connectionDraining": {
    "drainingTimeoutSec": 0
   }
}

Erstellen Sie die Weiterleitungsregel. Stellen Sie dazu eine POST-Anfrage an die Methode forwardingRules.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
  "name": "fr-ilb",
  "IPAddress": "10.1.2.99",
  "IPProtocol": "TCP",
  "ports": [
    "80", "8008", "8080", "8088"
  ],
  "loadBalancingScheme": "INTERNAL",
  "subnetwork": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/subnetworks/lb-subnet",
  "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
  "backendService": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/backendServices/be-ilb",
  "networkTier": "PREMIUM"
}

Test

Diese Tests zeigen Ihnen, wie Sie die Konfiguration des Load-Balancers validieren und das erwartete Verhalten ermitteln können.

Load-Balancing testen

Dieser Test nimmt von einer separaten Client-VM Verbindung mit dem Load-Balancer auf, also nicht von einer Back-End-VM des Load-Balancers. Dabei wird folgendes Verhalten erwartet: Der Traffic wird zwischen den vier Back-End-VMs verteilt, da keine Sitzungsaffinität konfiguriert wurde.

  1. Stellen Sie eine Verbindung zur Client-VM-Instanz her.

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

  2. Stellen Sie mit curl eine Webanfrage an den Load-Balancer, um dessen IP-Adresse zu kontaktieren. Wiederholen Sie die Anfrage. So können Sie sehen, dass Antworten von verschiedenen Back-End-VMs stammen. Der Name der VM, die die Antwort generiert, wird aufgrund des Inhalts von /var/www/html/index.html auf jeder Back-End-VM im Text der HTML-Antwort angezeigt. Die erwarteten Antworten sehen so aus: Page served from: vm-a1, Page served from: vm-a2, usw.

    curl http://10.1.2.99

    Die Weiterleitungsregel ist für die Bereitstellung der Ports 80, 8008, 8080 und 8088 konfiguriert. Um Traffic an diese anderen Ports zu senden, hängen Sie nach der IP-Adresse einen Doppelpunkt (:) und die Portnummer an:

    curl http://10.1.2.99:8008

    • Wenn Sie der internen Weiterleitungsregel ein Dienstlabel hinzufügen, können Sie mithilfe des internen DNS den Load-Balancer kontaktieren. Verwenden Sie dazu dessen Dienstnamen.

      curl http://web-test.fr-ilb.il4.us-west1.lb.project-id.internal

IP-Adresse des Load-Balancers per Ping kontaktieren

Dieser Test zeigt ein erwartetes Verhalten: Sie können die IP-Adresse des Load-Balancers nicht per Ping kontaktieren. Dies liegt daran, dass interne TCP/UDP-Load-Balancer durch virtuelle Netzwerkprogrammierung implementiert werden – sie sind keine separaten Geräte.

  1. Stellen Sie eine Verbindung zur Client-VM-Instanz her.

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

  2. Versuchen Sie, die IP-Adresse des Load-Balancers per Ping zu kontaktieren. Sie erhalten keine Antwort und der ping-Befehl überschreitet in diesem Beispiel nach 10 Sekunden des Zeitlimit.

    timeout 10 ping 10.1.2.99

Anfragen von VMs mit Load-Balancing senden

Dieser Test zeigt, dass Anfragen an den Load-Balancer, die von einer der Back-End-VMs, also den Server-VMs mit Load-Balancing, stammen, immer von derselben VM beantwortet werden, von der die Anfrage stammt.

Das interne TCP/UDP-Load-Balancing wird mithilfe von virtueller Netzwerkprogrammierung und VM-Konfiguration im Gastbetriebssystem implementiert. Auf Linux-VMs führt die Linux-Gastumgebung die lokale Konfiguration durch. Dazu installiert sie eine Route in der Routingtabelle des Gastbetriebssystems. Durch diese lokale Route bleibt der Traffic zur IP-Adresse des Load-Balancers in der VM mit Load-Balancing selbst. Diese lokale Route unterscheidet sich von den Routen im VPC-Netzwerk.

  1. Stellen Sie eine Verbindung zu einer Back-End-VM wie vm-a1 her:

    gcloud compute ssh vm-a1 --zone=us-west1-a

  2. Stellen Sie mit curl eine Webanfrage an den Load-Balancer (nach IP-Adresse oder Dienstname). Wiederholen Sie die Anfrage. Die Antwort wird von der Back-End-VM gesendet, von der die Anfrage stammt. Die erwartete Antwort beim Testen von vm-a1 lautet immer: Page served from: vm-a1.

    curl http://10.1.2.99

  3. Prüfen Sie die lokale Routingtabelle und suchen Sie nach einem Ziel, das mit der IP-Adresse des Load-Balancers selbst übereinstimmt: 10.1.2.99. Diese Route ist notwendiger Bestandteil des internen TCP/UDP-Load-Balancings. Zugleich zeigt sie, warum eine Anfrage von einer VM hinter dem Load-Balancer immer von derselben VM beantwortet wird.

    ip route show table local | grep 10.1.2.99

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.

Globalen Zugriff aktivieren

Sie können den globalen Zugriff für Ihr Beispiel eines internen TCP/UDP-Load-Balancers aktivieren, damit Clients in allen Regionen darauf zugreifen können. Die Back-Ends Ihres Beispiel-Load-Balancers müssen sich weiterhin in einer einzigen Region (us-west1) befinden.

Internes TCP/UDP-Load-Balancing mit globalem Zugriff (zum Vergrößern klicken)
Internes TCP/UDP-Load-Balancing mit globalem Zugriff (zum Vergrößern klicken)

Wenn Sie den globalen Zugriff konfigurieren möchten, nehmen Sie die folgenden Änderungen an der Konfiguration vor:

Console

Weiterleitungsregel des Load-Balancers bearbeiten

  1. Öffnen Sie in der Google Cloud Console die Seite "Load-Balancing".
    Zur Seite "Load-Balancing"

  2. Klicken Sie in der Spalte Name auf Ihren internen TCP/UDP-Load-Balancer. Der Beispiel-Load-Balancer hat den Namen be-ilb.

  3. Klicken Sie auf Front-End-Konfiguration.

  4. Klicken Sie auf Bearbeiten .

  5. Wählen Sie unter Globaler Zugriff die Option Aktivieren aus.

  6. Klicken Sie auf Fertig.

  7. Klicken Sie auf Aktualisieren.

Prüfen Sie auf der Seite Details zum Load-Balancer, ob die Front-End-Konfiguration Regional (REGION) mit globalem Zugriff lautet.

gcloud

  1. Aktualisieren Sie die Weiterleitungsregel fr-ilb des Beispiel-Load-Balancers so, dass das Flag --allow-global-access enthalten ist.

    gcloud compute forwarding-rules update fr-ilb \
   --region=us-west1 \
   --allow-global-access

  2. Achten Sie darauf, dass die Weiterleitungsregel globalen Zugriff zulässt.

    gcloud compute forwarding-rules describe fr-ilb \
   --region=us-west1 \
   --format="get(name,region,allowGlobalAccess)"

    Das Wort True wird in der Ausgabe nach dem Namen und der Region der Weiterleitungsregel angezeigt, wenn der globale Zugriff aktiviert ist.

API

Stellen Sie eine PATCH-Anfrage an die Methode forwardingRules/patch.

PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules/fr-ilb

{
  "allowGlobalAccess": true
}

VM-Client erstellen, um den globalen Zugriff zu testen

Console

  1. Rufen Sie in der Google Cloud Console die Seite „VM-Instanzen” auf.
    Zur Seite „VM-Instanzen”
  2. Klicken Sie auf Instanz erstellen.
  3. Legen Sie als Name vm-client2 fest.
  4. Setzen Sie Zone auf europe-west1-b.
  5. Klicken Sie auf Verwaltung, Sicherheit, Laufwerke, Netzwerke, einzelne Mandanten und nehmen Sie die folgenden Änderungen vor:
    • Klicken Sie auf Vernetzung und fügen Sie allow-ssh an die Netzwerk-Tags hinzu.
    • Klicken Sie unter Netzwerkschnittstellen auf die Schaltfläche "Bearbeiten", nehmen Sie die folgenden Änderungen vor und klicken Sie auf Fertig:
      • Netzwerk: lb-network
      • Subnetz: europe-subnet
      • Primäre interne IP: flüchtig (automatisch)
      • Externe IP: sitzungsspezifisch
  6. Klicken Sie auf Erstellen.

gcloud

Die Client-VM kann sich in einer beliebigen Zone in derselben Region wie der Load-Balancer befinden. Außerdem kann sie jedes Subnetz in dieser Region verwenden. In diesem Beispiel befindet sich der Client in der Zone europe-west1-b und verwendet dasselbe Subnetz wie die Back-End-VMs.

gcloud compute instances create vm-client2 \
    --zone=europe-west1-b \
    --image-family=debian-10 \
    --image-project=debian-cloud \
    --tags=allow-ssh \
    --subnet=europe-subnet

API

Stellen Sie eine POST-Anfrage an die Methode instances.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/europe-west1-b/instances

{
  "name": "vm-client2",
  "tags": {
    "items": [
      "allow-ssh"
    ]
  },
  "machineType": "https://www.googleapis.com/compute/v1/projects/project-id/zones/europe-west1-b/machineTypes/e2-standard-2",
  "canIpForward": false,
  "networkInterfaces": [
    {
      "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
      "subnetwork": "https://www.googleapis.com/compute/v1/projects/project-id/regions/europe-west1/subnetworks/europe-subnet",
      "accessConfigs": [
        {
          "type": "ONE_TO_ONE_NAT",
          "name": "external-nat",
          "networkTier": "PREMIUM"
        }
      ]
    }
  ],
  "disks": [
    {
      "type": "PERSISTENT",
      "boot": true,
      "mode": "READ_WRITE",
      "autoDelete": true,
      "deviceName": "vm-client2",
      "initializeParams": {
        "sourceImage": "projects/debian-cloud/global/images/debian-image-name",
        "diskType": "projects/project-id/zones/europe-west1-b/diskTypes/pd-standard",
        "diskSizeGb": "10"
      }
    }
  ],
  "scheduling": {
    "preemptible": false
  },
  "deletionProtection": false
}

Verbindung zum VM-Client herstellen und testen

gcloud compute ssh vm-client2 --zone=europe-west1-b

Testen Sie die Verbindung zum Load-Balancer auf allen konfigurierten Ports, wie Sie es vom vm-client in der Region us-west1 getan haben. Testen Sie die HTTP-Verbindung an den vier in der Weiterleitungsregel konfigurierten Ports:

curl http://10.1.2.99
curl http://10.1.2.99:8008
curl http://10.1.2.99:8080
curl http://10.1.2.99:8088

Verwaltete Instanzgruppen konfigurieren

In der Beispielkonfiguration wurden zwei nicht verwaltete Instanzgruppen erstellt. Sie können stattdessen auch verwaltete Instanzgruppen, darunter zonale und regionale verwaltete Instanzgruppen, als Back-Ends für das interne TCP/UDP-Load-Balancing verwenden.

Für verwaltete Instanzgruppen müssen Sie eine Instanzvorlage erstellen. Dieses Verfahren zeigt Ihnen, wie Sie die beiden nicht verwalteten zonalen Instanzgruppen aus dem Beispiel durch eine einzelne, regional verwaltete Instanzgruppe ersetzen. Eine regional verwaltete Instanzgruppe erstellt automatisch VMs in mehreren Zonen der Region. Das vereinfacht die Verteilung des Produktionstraffics auf die Zonen.

Verwaltete Instanzgruppen unterstützen auch Autoscaling und die automatische Reparatur. Wenn Sie Autoscaling mit internem TCP/UDP-Load-Balancing verwenden, können Sie keine Skalierung anhand von Load-Balancing durchführen.

Dieses Verfahren zeigt Ihnen, wie Sie den Back-End-Dienst für das interne TCP/UDP-Load-Balancing des Beispiels so ändern, dass er eine regional verwaltete Instanzgruppe verwendet.

Konsole

Instanzvorlage

  1. Öffnen Sie in der Google Cloud Console die Seite "VM-Instanzvorlagen".
    Zur Seite "VM-Instanzvorlagen"
  2. Klicken Sie auf Instanzvorlage erstellen.
  3. Legen Sie als Name template-vm-ilb fest.
  4. Wählen Sie einen Maschinentyp aus.
  5. Klicken Sie bei Bootlaufwerk auf Ändern, wählen Sie das Betriebssystem Debian und die Version 10 (Buster) aus.
  6. Klicken Sie auf Speichern, um die Optionen für dieses Bootlaufwerk zu bestätigen.

  7. Klicken Sie auf Verwaltung, Sicherheit, Laufwerke, Netzwerke, einzelne Mandanten.

    • Klicken Sie auf Netzwerke und nehmen Sie diese Änderungen vor:
      • Netzwerk: lb-network
      • Subnetz: lb-subnet
      • Netzwerk-Tags: allow-ssh und allow-health-check
    • Klicken Sie auf Verwaltung. Kopieren Sie den folgenden Skriptinhalt und fügen Sie ihn im Feld Startskript ein:
    #! /bin/bash
if [ -f /etc/startup_script_completed ]; then
exit 0
fi
apt-get update
apt-get install apache2 -y
a2ensite default-ssl
a2enmod ssl
file_ports="/etc/apache2/ports.conf"
file_http_site="/etc/apache2/sites-available/000-default.conf"
file_https_site="/etc/apache2/sites-available/default-ssl.conf"
http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
http_vh_prts="*:80 *:8008 *:8080 *:8088"
https_listen_prts="Listen 443\nListen 8443"
https_vh_prts="*:443 *:8443"
vm_hostname="$(curl -H "Metadata-Flavor:Google" \
http://169.254.169.254/computeMetadata/v1/instance/name)"
echo "Page served from: $vm_hostname" | \
tee /var/www/html/index.html
echo "Page served from: $vm_hostname" | \
tee /var/www/html/index.html
prt_conf="$(cat "$file_ports")"
prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
echo "$prt_conf" | tee "$file_ports"
http_site_conf="$(cat "$file_http_site")"
http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
echo "$http_site_conf_2" | tee "$file_http_site"
https_site_conf="$(cat "$file_https_site")"
https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
echo "$https_site_conf_2" | tee "$file_https_site"
systemctl restart apache2
touch /etc/startup_script_completed

  8. Klicken Sie auf Erstellen.

Verwaltete Instanzgruppe

  1. Öffnen Sie in der Google Cloud Console die Seite "VM-Instanzgruppen".
    Zur Seite "VM-Instanzgruppen"
  2. Klicken Sie auf Instanzgruppe erstellen.
  3. Legen Sie als Name ig-ilb fest.
  4. Wählen Sie als Standort die Option Mehrere Zonen aus und setzen Sie die Region auf us-west1.
  5. Stellen Sie die Instanzvorlage auf template-vm-ilb.
  6. (Optional) Konfigurieren Sie das Autoscaling. Sie können die Instanzgruppe nicht auf Basis der Verwendung von HTTP-Load-Balancing automatisch skalieren, da die Instanzgruppe ein Back-End für das interne TCP/UDP-Load-Balancing ist.
  7. Setzen Sie die Mindestanzahl an Instanzen auf 1 und die maximale Anzahl von Instanzen auf 6.
  8. (Optional) Konfigurieren Sie die automatische Reparatur. Wenn Sie die automatische Reparatur konfigurieren, verwenden Sie dieselbe Systemdiagnose, die der Back-End-Dienst für das interne TCP/UDP-Load-Balancing verwendet. Verwenden Sie in diesem Beispiel hc-http-80.
  9. Klicken Sie auf Erstellen.

gcloud

  1. Erstellen Sie die Instanzvorlage. Optional können Sie für die zu verwendende Image-Vorlage andere Parameter festlegen, beispielsweise den Maschinentyp.

    gcloud compute instance-templates create template-vm-ilb \
    --image-family=debian-10 \
    --image-project=debian-cloud \
    --tags=allow-ssh,allow-health-check \
    --subnet=lb-subnet \
    --region=us-west1 \
    --network=lb-network \
       --metadata=startup-script='#! /bin/bash
         if [ -f /etc/startup_script_completed ]; then
         exit 0
         fi
         apt-get update
         apt-get install apache2 -y
         a2ensite default-ssl
         a2enmod ssl
         file_ports="/etc/apache2/ports.conf"
         file_http_site="/etc/apache2/sites-available/000-default.conf"
         file_https_site="/etc/apache2/sites-available/default-ssl.conf"
         http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
         http_vh_prts="*:80 *:8008 *:8080 *:8088"
         https_listen_prts="Listen 443\nListen 8443"
         https_vh_prts="*:443 *:8443"
         vm_hostname="$(curl -H "Metadata-Flavor:Google" \
         http://169.254.169.254/computeMetadata/v1/instance/name)"
         echo "Page served from: $vm_hostname" | \
         tee /var/www/html/index.html
         prt_conf="$(cat "$file_ports")"
         prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
         prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
         echo "$prt_conf" | tee "$file_ports"
         http_site_conf="$(cat "$file_http_site")"
         http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
         echo "$http_site_conf_2" | tee "$file_http_site"
         https_site_conf="$(cat "$file_https_site")"
         https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
         echo "$https_site_conf_2" | tee "$file_https_site"
         systemctl restart apache2
         touch /etc/startup_script_completed'

  2. Erstellen Sie eine regional verwaltete Instanzgruppe mit der Vorlage:

    gcloud compute instance-groups managed create ig-ilb \
    --template=template-vm-ilb \
    --region=us-west1 \
    --size=6

  3. Fügen Sie dem bereits erstellten Back-End-Dienst die regional verwaltete Instanzgruppe als Back-End hinzu:

    gcloud compute backend-services add-backend be-ilb \
    --region=us-west1 \
    --instance-group=ig-ilb \
    --instance-group-region=us-west1

  4. Trennen Sie die Verbindung der beiden nicht verwalteten (zonalen) Instanzgruppen zum Back-End-Dienst:

    gcloud compute backend-services remove-backend be-ilb \
    --region=us-west1 \
    --instance-group=ig-a \
    --instance-group-zone=us-west1-a
gcloud compute backend-services remove-backend be-ilb \
    --region=us-west1 \
    --instance-group=ig-c \
    --instance-group-zone=us-west1-c

Externe IP-Adressen aus Backend-VMs entfernen

Bei der Erstellung der Backend-VMs wurde jeder eine sitzungsspezifische externe IP-Adresse zugewiesen, damit über ein Startskript Apache heruntergeladen werden konnte. Da die Back-End-VMs nur von einem internen Load-Balancer verwendet werden, können Sie deren externe IP-Adressen entfernen. Dadurch wird verhindert, dass die Back-End-VMs direkt auf das Internet zugreifen.

Console

  1. Rufen Sie in der Google Cloud Console die Seite „VM-Instanzen” auf.
    Zur Seite "VM-Instanzen"
  2. Wiederholen Sie die folgenden Schritte für jede Back-End-VM.
  3. Klicken Sie auf den Namen der Back-End-VM, z. B. vm-a1, um die Seite VM-Instanzdetails aufzurufen.
  4. Klicken Sie auf Bearbeiten .
  5. Klicken Sie im Bereich Netzwerkschnittstellen auf die Schaltfläche Bearbeiten.
  6. Wählen Sie im Pop-up-Fenster Externe IP die Option Keine aus und klicken Sie dann auf Fertig.
  7. Klicken Sie auf Speichern.

gcloud

  1. Wenn Sie die Zone einer Instanz, z. B. bei einer regionalen verwalteten Instanzgruppe, ermitteln möchten, führen Sie für jede Instanz den folgenden Befehl aus. Ersetzen Sie [SERVER-VM] durch den Namen der VM, die Sie aufrufen möchten.

    gcloud compute instances list --filter="name=[SERVER-VM]"

  2. Wiederholen Sie den folgenden Schritt für jede Back-End-VM. Ersetzen Sie [SERVER-VM] durch den Namen der VM und dann [ZONE] durch die Zone der VM.

    gcloud compute instances delete-access-config [SERVER-VM] \
    --zone=[ZONE] \
    --access-config-name=external-nat

API

Stellen Sie für jede Back-End-VM eine POST-Anfrage an die Methode instances.deleteAccessConfig. Ersetzen Sie dabei vm-a1 durch den Namen der VM und us-west1-a durch die Zone der VM.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances/vm-a1/deleteAccessConfig?accessConfig=external-nat&networkInterface=None

Traffic an allen Ports akzeptieren

Nicht die Back-End-Dienste bestimmen die Ports, an denen der Load-Balancer Traffic akzeptiert, sondern die Weiterleitungsregel des Load-Balancers. Informationen zum Zweck der einzelnen Komponenten finden Sie unter Komponenten.

Beim Erstellen der Weiterleitungsregel dieses Beispiel-Load-Balancers haben Sie die Ports 80, 8008, 8080 und 8088 konfiguriert. Das Startskript, mit dem Apache installiert wird, nimmt die Konfiguration so vor, dass HTTPS-Verbindungen über die Ports 443 und 8443 akzeptiert werden.

Zur Unterstützung dieser sechs Ports können Sie die Weiterleitungsregel so konfigurieren, dass Traffic an allen Ports akzeptiert wird. Mit dieser Strategie können Sie auch die Firewallregeln konfigurieren, die eingehende Verbindungen zu Back-End-VMs zulassen, sodass nur bestimmte Ports zulässig sind.

Dieses Verfahren zeigt Ihnen, wie Sie die Weiterleitungsregel des Beispiel-Load-Balancers durch eine Regel ersetzen, die Traffic an allen Ports akzeptiert.

Weitere Informationen zur Verwendung dieser Konfiguration finden Sie unter Internes TCP/UDP-Load-Balancing und Weiterleitungsregeln mit einer gemeinsamen IP-Adresse.

Console

Weiterleitungsregel löschen und neue erstellen

  1. Öffnen Sie in der Google Cloud Console die Seite "Load-Balancing".
    Zur Seite "Load-Balancing"
  2. Klicken Sie auf den be-ilb-Load-Balancer und dann auf Bearbeiten.
  3. Klicken Sie auf Front-End-Konfiguration.
  4. Bewegen Sie den Mauszeiger auf die Weiterleitungsregel 10.1.2.9 und klicken Sie auf das Papierkorbsymbol, um sie zu löschen.
  5. Klicken Sie auf Front-End-IP und -Port hinzufügen.
  6. Nehmen Sie im Bereich Neue Front-End-IP-Adresse und neuer Front-End-Port die folgenden Änderungen vor:
    1. Name: fr-ilb
    2. Subnetzwerk: lb-subnet
    3. Wählen Sie unter Interne IP-Adresse die Option ip-ilb aus.
    4. Ports: Alle
    5. Klicken Sie auf Fertig.
    6. Überprüfen Sie, bevor Sie fortfahren, ob sich neben der Front-End-Konfiguration ein blaues Häkchen befindet. Gehen Sie diesen Schritt noch einmal durch, wenn nicht.
  7. Klicken Sie auf Prüfen und abschließen. Kontrollieren Sie die Einstellungen.
  8. Klicken Sie auf Erstellen.

gcloud

  1. Löschen Sie die vorhandene Weiterleitungsregel fr-ilb.

    gcloud compute forwarding-rules delete fr-ilb \
    --region=us-west1

  2. Erstellen Sie eine Ersatzweiterleitungsregel mit demselben Namen, deren Portkonfiguration das Keyword ALL verwendet. Die anderen Parameter für die Weiterleitungsregel bleiben unverändert.

    gcloud compute forwarding-rules create fr-ilb \
    --region=us-west1 \
    --load-balancing-scheme=internal \
    --network=lb-network \
    --subnet=lb-subnet \
    --address=10.1.2.99 \
    --ip-protocol=TCP \
    --ports=ALL \
    --backend-service=be-ilb \
    --backend-service-region=us-west1

API

Löschen Sie die Weiterleitungsregel, indem Sie eine DELETE-Anfrage an die Methode forwardingRules.delete stellen.

DELETE https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules/fr-ilb

Erstellen Sie die Weiterleitungsregel. Stellen Sie dazu eine POST-Anfrage an die Methode forwardingRules.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
  "name": "fr-ilb",
  "IPAddress": "10.1.2.99",
  "IPProtocol": "TCP",
  "allPorts": true,
  "loadBalancingScheme": "INTERNAL",
  "subnetwork": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/subnetworks/lb-subnet",
  "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
  "backendService": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/backendServices/be-ilb",
  "networkTier": "PREMIUM"
}

Konfiguration mit Traffic an allen Ports testen

Stellen Sie eine Verbindung zur Client-VM-Instanz her und testen Sie HTTP- und HTTPS-Verbindungen.

  • Stellen Sie eine Verbindung zur Client-VM her:

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

  • Testen Sie die HTTP-Verbindung an allen vier Ports:

    curl http://10.1.2.99
curl http://10.1.2.99:8008
curl http://10.1.2.99:8080
curl http://10.1.2.99:8088

  • Testen Sie die HTTPS-Verbindung an den Ports 443 und 8443. Das Flag --insecure ist erforderlich, da jeder Apache-Server in der Beispielkonfiguration ein selbst signiertes Zertifikat verwendet.

    curl https://10.1.2.99 --insecure
 curl https://10.1.2.99:8443 --insecure

  • Beachten Sie, dass HTTP-Anfragen (an allen vier Ports) und HTTPS-Anfragen (an beiden Ports) auf alle Back-End-VMs verteilt werden.

Traffic an mehreren Ports mit zwei Weiterleitungsregeln akzeptieren

Beim Erstellen der Weiterleitungsregel dieses Beispiel-Load-Balancers haben Sie die Ports 80, 8008, 8080 und 8088 konfiguriert. Das Startskript, mit dem Apache installiert wird, nimmt die Konfiguration so vor, dass HTTPS-Verbindungen über die Ports 443 und 8443 akzeptiert werden.

Eine alternative Strategie zum Konfigurieren einer einzelnen Weiterleitungsregel für die Annahme von Traffic an allen Ports besteht darin, mehrere Weiterleitungsregeln zu erstellen, die jeweils maximal fünf Ports unterstützen.

Dieses Verfahren zeigt Ihnen, wie Sie die Weiterleitungsregel des Beispiel-Load-Balancers durch zwei Weiterleitungsregeln ersetzen, von denen eine Traffic an den Ports 80, 8008, 8080 und 8088 und die andere Traffic an den Ports 443 und 8443 verarbeitet.

Weitere Informationen zur Verwendung dieser Konfiguration finden Sie unter Internes TCP/UDP-Load-Balancing und Weiterleitungsregeln mit einer gemeinsamen IP-Adresse.

Console

  1. Rufen Sie in der Google Cloud Console die Seite Weiterleitungsregeln auf.
    Zur Seite „Weiterleitungsregeln”
  2. Wählen Sie fr-ilb aus.
  3. Klicken Sie auf Löschen.
  4. Öffnen Sie die Seite Load-Balancing.
    Zur Seite "Load-Balancing"
  5. Wählen Sie Ihren internen TCP/UDP-Load-Balancer aus. In diesem Beispiel: be-ilb.
  6. Klicken Sie auf Bearbeiten.
  7. Klicken Sie auf Front-End-Konfiguration.
  8. Klicken Sie auf Front-End-IP und -Port hinzufügen.
  9. Nehmen Sie im Bereich Neue Front-End-IP-Adresse und neuer Front-End-Port die folgenden Änderungen vor:
    1. Name: fr-ilb-http
    2. Subnetzwerk: lb-subnet
    3. Wählen Sie unter Zweck die Option Freigegeben aus.
    4. Wählen Sie unter Interne IP-Adresse die Option Statische interne IP-Adresse reservieren aus, geben Sie die folgenden Informationen ein und klicken Sie dann auf Reservieren:
      • Name: internal-10-1-2-99
      • Statische IP-Adresse: Selbst auswählen
      • Benutzerdefinierte IP-Adresse: 10.1.2.99
      • Klicken Sie auf Reservieren.
    5. Ports: Wählen Sie Mehrere aus und geben Sie 80,8008,8080,8088 als Portnummer ein.
    6. Klicken Sie auf Fertig.
  10. Klicken Sie auf Front-End-IP und Port hinzufügen.
  11. Nehmen Sie im Bereich Neue Front-End-IP-Adresse und neuer Front-End-Port die folgenden Änderungen vor:
    1. Name: fr-ilb-https
    2. Subnetzwerk: lb-subnet
    3. Wählen Sie unter Zweck die Option Freigegeben aus.
    4. Wählen Sie unter IP-Adresse internal-10-1-2-99 aus.
    5. Ports: Wählen Sie Mehrere aus und geben Sie 443,8443 als Portnummer ein.
    6. Klicken Sie auf Fertig.
    7. Überprüfen Sie, bevor Sie fortfahren, ob sich neben der Front-End-Konfiguration ein blaues Häkchen befindet. Gehen Sie diesen Schritt noch einmal durch, wenn nicht.
  12. Klicken Sie auf Prüfen und abschließen. Kontrollieren Sie die Einstellungen.
  13. Klicken Sie auf Aktualisieren.

gcloud

  1. Löschen Sie die vorhandene Weiterleitungsregel fr-ilb.

    gcloud compute forwarding-rules delete fr-ilb \
    --region=us-west1

  2. Erstellen Sie eine statische (reservierte) interne IP-Adresse für 10.1.2.99 und setzen Sie das Flag --purpose auf SHARED_LOADBALANCER_VIP. Das Flag --purpose ist erforderlich, damit zwei interne Weiterleitungsregeln dieselbe interne IP-Adresse verwenden können.

    gcloud compute addresses create internal-10-1-2-99 \
    --region=us-west1 \
    --subnet=lb-subnet \
    --addresses=10.1.2.99 \
    --purpose=SHARED_LOADBALANCER_VIP
    1. Erstellen Sie zwei Ersatzweiterleitungsregeln mit den folgenden Parametern:
    gcloud compute forwarding-rules create fr-ilb-http \
    --region=us-west1 \
    --load-balancing-scheme=internal \
    --network=lb-network \
    --subnet=lb-subnet \
    --address=10.1.2.99 \
    --ip-protocol=TCP \
    --ports=80,8008,8080,8088 \
    --backend-service=be-ilb \
    --backend-service-region=us-west1

    gcloud compute forwarding-rules create fr-ilb-https \
    --region=us-west1 \
    --load-balancing-scheme=internal \
    --network=lb-network \
    --subnet=lb-subnet \
    --address=10.1.2.99 \
    --ip-protocol=TCP \
    --ports=443,8443 \
    --backend-service=be-ilb \
    --backend-service-region=us-west1

API

Löschen Sie die Weiterleitungsregel, indem Sie eine DELETE-Anfrage an die Methode forwardingRules.delete stellen.

DELETE https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules/fr-ilb

Erstellen Sie eine statische (reservierte) interne IP-Adresse für 10.1.2.99 und legen Sie deren Zweck auf SHARED_LOADBALANCER_VIP fest. Stellen Sie dazu eine POST-Anfrage an die Methode addresses.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/addresses

{
  "name": "internal-10-1-2-99",
  "address": "10.1.2.99",
  "prefixLength": 32,
  "addressType": INTERNAL,
  "purpose": SHARED_LOADBALANCER_VIP,
  "subnetwork": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/subnetworks/lb-subnet"
}

Erstellen Sie zwei Weiterleitungsregeln, indem Sie zwei POST-Anfragen an die Methode forwardingRules.insert stellen.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
  "name": "fr-ilb-http",
  "IPAddress": "10.1.2.99",
  "IPProtocol": "TCP",
  "ports": [
    "80", "8008", "8080",  "8088"
  ],
  "loadBalancingScheme": "INTERNAL",
  "subnetwork": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/subnetworks/lb-subnet",
  "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
  "backendService": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/backendServices/be-ilb",
  "networkTier": "PREMIUM"
}

{
  "name": "fr-ilb-https",
  "IPAddress": "10.1.2.99",
  "IPProtocol": "TCP",
  "ports": [
    "443", "8443"
  ],
  "loadBalancingScheme": "INTERNAL",
  "subnetwork": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/subnetworks/lb-subnet",
  "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
  "backendService": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/backendServices/be-ilb",
  "networkTier": "PREMIUM"
}

Konfiguration mit Traffic an mehreren Ports testen

Stellen Sie eine Verbindung zur Client-VM-Instanz her und testen Sie HTTP- und HTTPS-Verbindungen.

  • Stellen Sie eine Verbindung zur Client-VM her:

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

  • Testen Sie die HTTP-Verbindung an allen vier Ports:

    curl http://10.1.2.99
curl http://10.1.2.99:8008
curl http://10.1.2.99:8080
curl http://10.1.2.99:8088

  • Testen Sie die HTTPS-Verbindung an den Ports 443 und 8443. Das Flag --insecure ist erforderlich, da jeder Apache-Server in der Beispielkonfiguration ein selbst signiertes Zertifikat verwendet.

    curl https://10.1.2.99 --insecure
curl https://10.1.2.99:8443 --insecure

  • Beachten Sie, dass HTTP-Anfragen (an allen vier Ports) und HTTPS-Anfragen (an beiden Ports) auf alle Back-End-VMs verteilt werden.

Sitzungsaffinität verwenden

Die Beispielkonfiguration erstellt einen Back-End-Dienst ohne Sitzungsaffinität.

Dieses Verfahren zeigt Ihnen, wie Sie den Back-End-Dienst für den internen TCP/UDP-Load-Balancer aus dem Beispiel so aktualisieren, dass er Sitzungsaffinität auf Grundlage eines Hash-Werts verwendet, der aus den IP-Adressen des Clients und der IP-Adresse der internen Weiterleitungsregel des Load-Balancers erstellt wird. Beachten Sie, dass das Festlegen der Sitzungsaffinität für einen internen UDP-Load-Balancer derzeit nicht unterstützt wird.

Console

  1. Öffnen Sie in der Google Cloud Console die Seite „Load-Balancing“.
    Zur Seite "Load-Balancing"
  2. Klicken Sie auf be-ilb. Das ist der Name des für dieses Beispiel erstellten Back-End-Dienstes. Klicken Sie dann auf Bearbeiten.
  3. Klicken Sie auf der Seite Internen Load-Balancer bearbeiten auf Back-End-Konfiguration.
  4. Wählen Sie aus dem Pop-up-Menü Sitzungsaffinität die Option Client-IP aus.
  5. Klicken Sie auf Aktualisieren.

gcloud

Aktualisieren Sie den Back-End-Dienst be-ilb mit dem folgenden gcloud-Befehl. Geben Sie dabei die Sitzungsaffinität der Client-IP-Adresse an:

gcloud compute backend-services update be-ilb \
    --region=us-west1 \
    --session-affinity CLIENT_IP

API

Stellen Sie eine PATCH-Anfrage an die Methode regionBackendServices/patch.

PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb

{
  "sessionAffinity": "CLIENT_IP"
}

Weitere Informationen zum Verwenden der Sitzungsaffinität, um die Verteilung von Traffic zu beeinflussen, sowie eine Beschreibung der einzelnen Optionen finden Sie unter Trafficverteilung.

Weiterleitungsregel in einem anderen Subnetz erstellen

Dieses Verfahren erstellt eine zweite IP-Adresse und Weiterleitungsregel in einem anderen Subnetz. Dies dient dazu, Ihnen zu zeigen, dass Sie für einen internen TCP/UDP-Load-Balancer mehrere Weiterleitungsregeln erstellen können. Die Region für die Weiterleitungsregel muss dabei mit der Region des Back-End-Dienstes übereinstimmen.

Je nach Firewallregeln können Clients in jedem Subnetz in der Region eine der internen IP-Adressen des TCP/UDP-Load-Balancers kontaktieren.

Console

Zweites Subnetz hinzufügen

  1. Rufen Sie in der Google Cloud Console die Seite „VPC-Netzwerke“ auf.
    Zur VPC-Netzwerkseite
  2. Klicken Sie auf VPC-Netzwerk erstellen.
  3. Klicken Sie auf lb-network.
  4. Im Bereich Subnetze:
    • Klicken Sie auf Subnetz hinzufügen.
    • Geben Sie im Bereich Neues Subnetz folgende Informationen ein:
      • Name: second-subnet
      • Region: us-west1
      • IP-Adressbereich: 10.5.6.0/24
      • Klicken Sie auf Hinzufügen.

Zweite Weiterleitungsregel hinzufügen

  1. Öffnen Sie in der Google Cloud Console die Seite "Load-Balancing".
    Zur Seite "Load-Balancing"
  2. Klicken Sie auf den be-ilb-Load-Balancer und dann auf Bearbeiten.
  3. Klicken Sie auf Front-End-Konfiguration.
  4. Klicken Sie auf Front-End-IP und -Port hinzufügen.
  5. Nehmen Sie im Bereich Neue Front-End-IP-Adresse und neuer Front-End-Port die folgenden Änderungen vor:
    1. Name: fr-ilb-2
    2. Subnetzwerk: second-subnet
    3. Wählen Sie unter Interne IP-Adresse die Option ip-ilb aus.
    4. Ports: 80, 443
    5. Klicken Sie auf Fertig.
    6. Überprüfen Sie, bevor Sie fortfahren, ob sich neben der Front-End-Konfiguration ein blaues Häkchen befindet. Gehen Sie diesen Schritt noch einmal durch, wenn nicht.
  6. Klicken Sie auf Prüfen und abschließen. Kontrollieren Sie die Einstellungen.
  7. Klicken Sie auf Erstellen.

gcloud

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

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

  2. Erstellen Sie eine zweite Weiterleitungsregel für die Ports 80 und 443. Die anderen Parameter für diese Regel, einschließlich IP-Adresse und Back-End-Dienst, sind dieselben wie für die primäre Weiterleitungsregel fr-ilb.

    gcloud compute forwarding-rules create fr-ilb-2 \
   --region=us-west1 \
   --load-balancing-scheme=internal \
   --network=lb-network \
   --subnet=second-subnet \
   --address=10.5.6.99 \
   --ip-protocol=TCP \
   --ports=80,443 \
   --backend-service=be-ilb \
   --backend-service-region=us-west1

API

Stellen Sie eine POST-Anfrage an die Methode subnetworks.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks

{
  "name": "second-subnet",
  "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
  "ipCidrRange": "10.5.6.0/24",
  "privateIpGoogleAccess": false
}

Erstellen Sie die Weiterleitungsregel. Stellen Sie dazu eine POST-Anfrage an die Methode forwardingRules.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
 "name": "fr-ilb-2",
 "IPAddress": "10.5.6.99",
 "IPProtocol": "TCP",
 "ports": [
   "80", "443"
 ],
 "loadBalancingScheme": "INTERNAL",
 "subnetwork": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/subnetworks/lb-subnet",
 "network": "https://www.googleapis.com/compute/v1/projects/project-id/global/networks/lb-network",
 "backendService": "https://www.googleapis.com/compute/v1/projects/project-id/regions/us-west1/backendServices/be-ilb",
 "networkTier": "PREMIUM"
}

Neue Weiterleitungsregel testen

  1. Stellen Sie eine Verbindung zur Client-VM-Instanz her und testen Sie HTTP- und HTTPS-Verbindungen zu den IP-Adressen.

    • Stellen Sie eine Verbindung zur Client-VM her:
    gcloud compute ssh vm-client --zone=us-west1-a
    • Testen Sie die HTTP-Konnektivität zu den IP-Adressen:
    curl http://10.1.2.99
curl http://10.5.6.99
    • Testen Sie die HTTPS-Konnektivität. Die Verwendung von --insecure ist erforderlich, da für die Apache-Serverkonfiguration im Beispiel selbst signierte Zertifikate verwendet werden.
    curl https://10.1.2.99 --insecure
curl https://10.5.6.99 --insecure
    • Beachten Sie, dass Anfragen von allen Back-End-VMs verarbeitet werden, unabhängig vom verwendeten Protokoll (HTTP oder HTTPS) oder der verwendeten IP-Adresse.

Weitere Informationen