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:
- Konzepte für das interne TCP/UDP-Load-Balancing
- Übersicht über Firewallregeln
- Systemdiagnosekonzepte
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:
- ein VPC-Netzwerk mit benutzerdefinierten Subnetzen als Beispiel
- Firewall-Regeln, die eingehende Verbindung zu Back-End-VMs ermöglichen
- 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
- Zwei VMs in einer nicht verwalteten Instanzgruppe in Zone
- Eine Client-VM zum Testen von Verbindungen
- 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:
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-Adressbereich10.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-Adressbereich10.3.4.0/24
Gehen Sie so vor, um das Netzwerk und das Subnetz zu erstellen:
Console
- Rufen Sie in der Google Cloud Console die Seite „VPC-Netzwerke“ auf.
Zur VPC-Netzwerkseite - Klicken Sie auf VPC-Netzwerk erstellen.
- Geben Sie als Name
lb-network
ein. - 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.
- Name:
- 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.
- Name:
- Klicken Sie auf Erstellen.
gcloud
Erstellen Sie das benutzerdefinierte VPC-Netzwerk:
gcloud compute networks create lb-network --subnet-mode=custom
- Erstellen Sie im Netzwerk
lb-network
ein Subnetz für Back-Ends in der Regionus-west1
und ein anderes Subnetz zum Testen des globalen Zugriffs in der Regioneurope-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
- Erstellen Sie im Netzwerk
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 Bereichen10.1.2.0/24
und10.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-Tagallow-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
und35.191.0.0/16
). In diesem Beispiel wird das Ziel-Tagallow-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
- Rufen Sie in der Google Cloud Console die Seite „Firewallregeln“ auf.
Zur Seite "Firewallregeln" - 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
und10.3.4.0/24
- Protokolle und Ports: Alle zulassen
- Name:
- Klicken Sie auf Erstellen.
- 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
- Name:
- Klicken Sie auf Erstellen.
- 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
und35.191.0.0/16
- Protokolle und Ports: Alle zulassen
- Name:
- Klicken Sie auf Erstellen.
gcloud
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
Erstellen Sie die Firewallregel
fw-allow-ssh
, um SSH-Verbindungen zu VMs mit dem Netzwerk-Tagallow-ssh
zu ermöglichen. Wenn Siesource-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
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
- Rufen Sie in der Google Cloud Console die Seite „VM-Instanzen” auf.
Zur Seite "VM-Instanzen" - 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
- Name:
- Klicken Sie auf Instanz erstellen.
- Legen Sie den Namen wie in Schritt 2 angegeben fest.
- Wählen Sie für die Region
us-west1
aus und legen Sie die Zone wie in Schritt 2 angegeben fest. - 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.
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
undallow-health-check
. - Klicken Sie unter Netzwerkschnittstellen auf Bearbeiten
- Netzwerk:
lb-network
- Subnetz:
lb-subnet
- Primäre interne IP: flüchtig (automatisch)
- Externe IP: sitzungsspezifisch
, nehmen Sie die folgenden Änderungen vor und klicken Sie dann auf Fertig: - Netzwerk:
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
- Klicken Sie auf Netzwerke und fügen Sie die folgenden Netzwerk-Tags hinzu:
Klicken Sie auf Erstellen.
Instanzgruppen erstellen
- Öffnen Sie in der Google Cloud Console die Seite "Instanzgruppen".
Zur Seite "Instanzgruppen" - 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
undvm-a2
- Instanzgruppe:
ig-c
, Zone:us-west1-c
, VMs:vm-c1
undvm-c2
- Instanzgruppe:
- Klicken Sie auf Instanzgruppe erstellen.
- Klicken Sie auf Neue nicht verwaltete Instanzgruppe.
- Legen Sie Name wie in Schritt 2 angegeben fest.
- Wählen Sie im Bereich Standort als Region
us-west1
aus und legen Sie dann wie in Schritt 2 angegeben eine Zone fest. - Geben Sie bei Netzwerk den Parameter
lb-network
ein. - Geben Sie bei Subnetzwerk den Parameter
lb-subnet
ein. - Fügen Sie im Bereich VM-Instanzen die in Schritt 2 angegebenen VMs hinzu.
- Klicken Sie auf Erstellen.
gcloud
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'
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
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
- Rufen Sie in der Google Cloud Console die Seite „VM-Instanzen” auf.
Zur Seite „VM-Instanzen” - Klicken Sie auf Instanz erstellen.
- Legen Sie als Name
vm-client
fest. - Setzen Sie Zone auf
us-west1-a
. - 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
- Netzwerk:
- Klicken Sie auf Vernetzung und fügen Sie
- 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
- Öffnen Sie in der Google Cloud Console die Seite "Load-Balancing".
Zur Seite "Load-Balancing" - Klicken Sie auf Load-Balancer erstellen.
- Klicken Sie unter TCP-Load-Balancing auf Konfiguration starten.
- Wählen Sie unter Internet oder nur intern die Option Nur zwischen meinen VMs aus.
- Klicken Sie auf Weiter.
- Legen Sie als Name
be-ilb
fest. - Klicken Sie auf Back-End-Konfiguration und nehmen Sie folgende Änderungen vor:
- Region:
us-west1
- Netzwerk:
lb-network
- Wählen Sie unter Back-Ends im Bereich Neues Element die Instanzgruppe
ig-a
aus und klicken Sie auf Fertig. - 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. - 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 Siegcloud
oder die API.
- Name:
- 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.
- Region:
- Klicken Sie auf Front-End-Konfiguration. Nehmen Sie im Bereich Neue Front-End-IP-Adresse und neuer Front-End-Port die folgenden Änderungen vor:
- Name:
fr-ilb
- Subnetzwerk:
lb-subnet
- 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
- Name:
- Ports: Wählen Sie Mehrere aus und geben Sie
80,8008,8080,8088
als Portnummer ein. - Ü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.
- Name:
- Klicken Sie auf Prüfen und abschließen. Kontrollieren Sie die Einstellungen.
- Klicken Sie auf Erstellen.
gcloud
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
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
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
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.
Stellen Sie eine Verbindung zur Client-VM-Instanz her.
gcloud compute ssh vm-client --zone=us-west1-a
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
und8088
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.
Stellen Sie eine Verbindung zur Client-VM-Instanz her.
gcloud compute ssh vm-client --zone=us-west1-a
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.
Stellen Sie eine Verbindung zu einer Back-End-VM wie
vm-a1
her:gcloud compute ssh vm-a1 --zone=us-west1-a
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 vonvm-a1
lautet immer:Page served from: vm-a1
.curl http://10.1.2.99
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.
Wenn Sie den globalen Zugriff konfigurieren möchten, nehmen Sie die folgenden Änderungen an der Konfiguration vor:
Console
Weiterleitungsregel des Load-Balancers bearbeiten
- Öffnen Sie in der Google Cloud Console die Seite "Load-Balancing".
Zur Seite "Load-Balancing" Klicken Sie in der Spalte Name auf Ihren internen TCP/UDP-Load-Balancer. Der Beispiel-Load-Balancer hat den Namen
be-ilb
.Klicken Sie auf Front-End-Konfiguration.
Klicken Sie auf Bearbeiten
.Wählen Sie unter Globaler Zugriff die Option Aktivieren aus.
Klicken Sie auf Fertig.
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
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
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
- Rufen Sie in der Google Cloud Console die Seite „VM-Instanzen” auf.
Zur Seite „VM-Instanzen” - Klicken Sie auf Instanz erstellen.
- Legen Sie als Name
vm-client2
fest. - Setzen Sie Zone auf
europe-west1-b
. - 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
- Netzwerk:
- Klicken Sie auf Vernetzung und fügen Sie
- 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
- Öffnen Sie in der Google Cloud Console die Seite "VM-Instanzvorlagen".
Zur Seite "VM-Instanzvorlagen" - Klicken Sie auf Instanzvorlage erstellen.
- Legen Sie als Name
template-vm-ilb
fest. - Wählen Sie einen Maschinentyp aus.
- Klicken Sie bei Bootlaufwerk auf Ändern, wählen Sie das Betriebssystem Debian und die Version 10 (Buster) aus.
- Klicken Sie auf Speichern, um die Optionen für dieses Bootlaufwerk zu bestätigen.
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
undallow-health-check
- Netzwerk:
- 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
- Klicken Sie auf Netzwerke und nehmen Sie diese Änderungen vor:
Klicken Sie auf Erstellen.
Verwaltete Instanzgruppe
- Öffnen Sie in der Google Cloud Console die Seite "VM-Instanzgruppen".
Zur Seite "VM-Instanzgruppen" - Klicken Sie auf Instanzgruppe erstellen.
- Legen Sie als Name
ig-ilb
fest. - Wählen Sie als Standort die Option Mehrere Zonen aus und setzen Sie die Region auf
us-west1
. - Stellen Sie die Instanzvorlage auf
template-vm-ilb
. - (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.
- Setzen Sie die Mindestanzahl an Instanzen auf
1
und die maximale Anzahl von Instanzen auf6
. - (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
. - Klicken Sie auf Erstellen.
gcloud
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'
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
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
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
- Rufen Sie in der Google Cloud Console die Seite „VM-Instanzen” auf.
Zur Seite "VM-Instanzen" - Wiederholen Sie die folgenden Schritte für jede Back-End-VM.
- Klicken Sie auf den Namen der Back-End-VM, z. B.
vm-a1
, um die Seite VM-Instanzdetails aufzurufen. - Klicken Sie auf Bearbeiten .
- Klicken Sie im Bereich Netzwerkschnittstellen auf die Schaltfläche Bearbeiten.
- Wählen Sie im Pop-up-Fenster Externe IP die Option Keine aus und klicken Sie dann auf Fertig.
- Klicken Sie auf Speichern.
gcloud
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]"
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
- Öffnen Sie in der Google Cloud Console die Seite "Load-Balancing".
Zur Seite "Load-Balancing" - Klicken Sie auf den
be-ilb
-Load-Balancer und dann auf Bearbeiten. - Klicken Sie auf Front-End-Konfiguration.
- Bewegen Sie den Mauszeiger auf die Weiterleitungsregel 10.1.2.9 und klicken Sie auf das Papierkorbsymbol, um sie zu löschen.
- Klicken Sie auf Front-End-IP und -Port hinzufügen.
- Nehmen Sie im Bereich Neue Front-End-IP-Adresse und neuer Front-End-Port die folgenden Änderungen vor:
- Name:
fr-ilb
- Subnetzwerk:
lb-subnet
- Wählen Sie unter Interne IP-Adresse die Option
ip-ilb
aus. - Ports: Alle
- Klicken Sie auf Fertig.
- Ü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.
- Name:
- Klicken Sie auf Prüfen und abschließen. Kontrollieren Sie die Einstellungen.
- Klicken Sie auf Erstellen.
gcloud
Löschen Sie die vorhandene Weiterleitungsregel
fr-ilb
.gcloud compute forwarding-rules delete fr-ilb \ --region=us-west1
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
und8443
. 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
- Rufen Sie in der Google Cloud Console die Seite Weiterleitungsregeln auf.
Zur Seite „Weiterleitungsregeln” - Wählen Sie
fr-ilb
aus. - Klicken Sie auf Löschen.
- Öffnen Sie die Seite Load-Balancing.
Zur Seite "Load-Balancing" - Wählen Sie Ihren internen TCP/UDP-Load-Balancer aus. In diesem Beispiel:
be-ilb
. - Klicken Sie auf Bearbeiten.
- Klicken Sie auf Front-End-Konfiguration.
- Klicken Sie auf Front-End-IP und -Port hinzufügen.
- Nehmen Sie im Bereich Neue Front-End-IP-Adresse und neuer Front-End-Port die folgenden Änderungen vor:
- Name:
fr-ilb-http
- Subnetzwerk:
lb-subnet
- Wählen Sie unter Zweck die Option Freigegeben aus.
- 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.
- Name:
- Ports: Wählen Sie Mehrere aus und geben Sie
80,8008,8080,8088
als Portnummer ein. - Klicken Sie auf Fertig.
- Name:
- Klicken Sie auf Front-End-IP und Port hinzufügen.
- Nehmen Sie im Bereich Neue Front-End-IP-Adresse und neuer Front-End-Port die folgenden Änderungen vor:
- Name:
fr-ilb-https
- Subnetzwerk:
lb-subnet
- Wählen Sie unter Zweck die Option Freigegeben aus.
- Wählen Sie unter IP-Adresse
internal-10-1-2-99
aus. - Ports: Wählen Sie Mehrere aus und geben Sie
443,8443
als Portnummer ein. - Klicken Sie auf Fertig.
- Ü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.
- Name:
- Klicken Sie auf Prüfen und abschließen. Kontrollieren Sie die Einstellungen.
- Klicken Sie auf Aktualisieren.
gcloud
Löschen Sie die vorhandene Weiterleitungsregel
fr-ilb
.gcloud compute forwarding-rules delete fr-ilb \ --region=us-west1
Erstellen Sie eine statische (reservierte) interne IP-Adresse für
10.1.2.99
und setzen Sie das Flag--purpose
aufSHARED_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
- 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
und8443
. 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
- Öffnen Sie in der Google Cloud Console die Seite „Load-Balancing“.
Zur Seite "Load-Balancing" - Klicken Sie auf be-ilb. Das ist der Name des für dieses Beispiel erstellten Back-End-Dienstes. Klicken Sie dann auf Bearbeiten.
- Klicken Sie auf der Seite Internen Load-Balancer bearbeiten auf Back-End-Konfiguration.
- Wählen Sie aus dem Pop-up-Menü Sitzungsaffinität die Option Client-IP aus.
- 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
- Rufen Sie in der Google Cloud Console die Seite „VPC-Netzwerke“ auf.
Zur VPC-Netzwerkseite - Klicken Sie auf VPC-Netzwerk erstellen.
- Klicken Sie auf
lb-network
. - 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.
- Name:
Zweite Weiterleitungsregel hinzufügen
- Öffnen Sie in der Google Cloud Console die Seite "Load-Balancing".
Zur Seite "Load-Balancing" - Klicken Sie auf den
be-ilb
-Load-Balancer und dann auf Bearbeiten. - Klicken Sie auf Front-End-Konfiguration.
- Klicken Sie auf Front-End-IP und -Port hinzufügen.
- Nehmen Sie im Bereich Neue Front-End-IP-Adresse und neuer Front-End-Port die folgenden Änderungen vor:
- Name:
fr-ilb-2
- Subnetzwerk:
second-subnet
- Wählen Sie unter Interne IP-Adresse die Option
ip-ilb
aus. - Ports: 80, 443
- Klicken Sie auf Fertig.
- Ü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.
- Name:
- Klicken Sie auf Prüfen und abschließen. Kontrollieren Sie die Einstellungen.
- Klicken Sie auf Erstellen.
gcloud
Erstellen Sie ein zweites Subnetz im Netzwerk
lb-network
in der Regionus-west1
:gcloud compute networks subnets create second-subnet \ --network=lb-network \ --range=10.5.6.0/24 \ --region=us-west1
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
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
- Wichtige Grundlagen finden Sie unter Konzepte von internem TCP/UDP-Load-Balancing.
- Wichtige Informationen zum Failover finden Sie unter Failover-Konzepte für das interne TCP/UDP-Load-Balancing.
- Informationen zu verfügbaren DNS-Namen, die der Load-Balancer verwenden kann, finden Sie unter Internes Load-Balancing und DNS-Namen.
- Konfigurationsschritte und ein Beispiel für eine Failover-Konfiguration finden Sie unter Failover für internes TCP/UDP-Load-Balancing konfigurieren.
- Informationen zum Konfigurieren von Logging und Monitoring für das interne TCP/UDP-Load-Balancing finden Sie unter Logging und Monitoring für internes TCP/UDP-Load-Balancing.
- Mehr zum Zugriff auf interne TCP/UDP-Load-Balancer über Peer-Netzwerke, die mit Ihrem VPC-Netzwerk verbunden sind, unter Internes TCP/UDP-Load-Balancing und verbundene Netzwerke erfahren
- Wie Sie Probleme mit dem internen TCP/UDP-Load-Balancer beheben, erfahren Sie unter Fehlerbehebung beim internen TCP/UDP-Load-Balancing.
- Einrichtung des Load-Balancers bereinigen