Diese Seite wurde von der Cloud Translation API übersetzt.

Dynamische Portzuweisung von Cloud NAT verwenden

1. Übersicht

Die dynamische Portzuweisung (Dynamic Port Allocation, DPA) ist eine neue Funktion in Cloud NAT. Wenn DPA aktiviert ist, skaliert Cloud NAT die Portzuweisungen für Instanzen je nach Bedarf dynamisch nach oben oder unten. DPA ist mit minimalen und maximalen Portlimits konfiguriert, damit Ports nie unter dem Mindestwert herunterskaliert oder über das Maximum hinaus skaliert werden. Dadurch können einige Instanzen hinter NAT-Gateways die Anzahl der Verbindungen dynamisch hochskalieren, ohne allen Instanzen hinter Cloud NAT mehr Ports zuweisen zu müssen.

Ohne DPA wird allen Instanzen hinter Cloud NAT unabhängig von der Nutzung dieselbe Anzahl von Ports zugewiesen, wie durch den Parameter minPortsPerVm definiert .

Weitere Informationen finden Sie im Dokumentationsabschnitt zum NAT DPA .

Aufgaben in diesem Lab

Anleitung zum Einrichten eines Cloud NAT-Gateways zur Vorbereitung auf die Datenverarbeitung
Portzuweisungen ohne Zusatz zur Datenverarbeitung prüfen
DPA für ein NAT-Gateway aktivieren und konfigurieren
Wie sich die Auswirkungen des Zusatzes zur Datenverarbeitung durch parallele ausgehende Verbindungen beobachten lassen.
So fügen Sie einem NAT-Gateway mit aktivierter DPA NAT-Regeln hinzu.
So können Sie das Verhalten der Datenschutzaufsichtsbehörde mit Regeln beobachten, indem Sie ausgehende Verbindungen zu mehreren Zielen ausführen.

Voraussetzungen

Grundkenntnisse hinsichtlich der Google Compute Engine
Grundkenntnisse in den Bereichen Netzwerk und TCP/IP
Grundkenntnisse zu Unix/Linux-Befehlszeilen
Es ist hilfreich, eine Tour zum Thema Netzwerke in Google Cloud zu absolvieren, z. B. das Lab Netzwerke in Google Cloud.
Ein Google Cloud-Projekt mit „Alphazugriff“ aktiviert.
Kenntnisse der Grundlagen von Cloud NAT

2. Google Cloud Console und Cloud Shell verwenden

Für die Interaktion mit der GCP verwenden wir in diesem Lab sowohl die Google Cloud Console als auch Cloud Shell.

Google Cloud Console

Die Cloud Console ist unter https://console.cloud.google.com erreichbar.

Umgebung für das selbstbestimmte Lernen einrichten

Melden Sie sich in der Google Cloud Console an und erstellen Sie ein neues Projekt oder verwenden Sie ein vorhandenes Projekt. Wenn Sie noch kein Gmail- oder Google Workspace-Konto haben, müssen Sie eines erstellen.

Der Projektname ist der Anzeigename für die Projektteilnehmer. Es handelt sich um eine Zeichenfolge, die von Google APIs nicht verwendet wird und jederzeit aktualisiert werden kann.
Die Projekt-ID muss für alle Google Cloud-Projekte eindeutig sein und ist unveränderlich. Sie kann nach dem Festlegen nicht mehr geändert werden. Die Cloud Console generiert automatisch einen eindeutigen String. ist Ihnen meist egal, was es ist. In den meisten Codelabs musst du auf die Projekt-ID verweisen, die in der Regel als PROJECT_ID identifiziert wird. Wenn es dir nicht gefällt, kannst du eine weitere zufällige Projekt-ID generieren. Du kannst aber auch selbst eine andere testen, um zu sehen, ob sie verfügbar ist. Dann ist es „eingefroren“ nachdem das Projekt erstellt wurde.
Es gibt einen dritten Wert, die Projektnummer, die von einigen APIs verwendet wird. Weitere Informationen zu allen drei Werten finden Sie in der Dokumentation.

Als Nächstes müssen Sie in der Cloud Console die Abrechnung aktivieren, um Cloud-Ressourcen/APIs verwenden zu können. Dieses Codelab sollte möglichst wenig kosten. Wenn Sie Ressourcen beenden möchten, damit über diese Anleitung hinaus keine Kosten anfallen, führen Sie eine Bereinigung durch am Ende des Codelabs. Neue Google Cloud-Nutzer haben Anspruch auf eine kostenlose Testversion mit 300$Guthaben.

Cloud Shell starten

Sie können Google Cloud zwar von Ihrem Laptop aus der Ferne bedienen, in diesem Codelab verwenden Sie jedoch Google Cloud Shell, eine Befehlszeilenumgebung, die in der Cloud ausgeführt wird.

Klicken Sie in der GCP Console oben rechts in der Symbolleiste auf das Cloud Shell-Symbol:

Die Bereitstellung und Verbindung mit der Umgebung dauert nur einen Moment. Wenn er abgeschlossen ist, sollten Sie in etwa Folgendes sehen:

Diese virtuelle Maschine verfügt über sämtliche Entwicklertools, die Sie benötigen. Es bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und läuft auf Google Cloud, wodurch die Netzwerkleistung und Authentifizierung erheblich verbessert werden. Sie können alle Aufgaben in diesem Lab ganz einfach in einem Browser erledigen.

3. Lab einrichten

In diesem Lab verwenden Sie ein Projekt und erstellen zwei VPCs mit jeweils einem Subnetz. Sie reservieren externe IP-Adressen und erstellen und konfigurieren dann ein Cloud NAT-Gateway (mit einem Cloud Router), zwei Producer-Instanzen sowie zwei Nutzerinstanzen. Nachdem Sie das Cloud NAT-Standardverhalten geprüft haben, aktivieren Sie die dynamische Portzuweisung und validieren ihr Verhalten. Schließlich konfigurieren Sie NAT-Regeln und beobachten die Interaktion zwischen dem Zusatz zur Datenverarbeitung und den NAT-Regeln.

Netzwerkarchitektur – Übersicht:

4. Externe IP-Adressen reservieren

Jetzt reservieren wir alle externen IP-Adressen für dieses Lab. So können Sie alle relevanten NAT- und Firewallregeln sowohl in der Nutzer- als auch in der Producer-VPC schreiben.

In Cloud Shell:

gcloud compute addresses  create nat-address-1 nat-address-2 \
 producer-address-1 producer-address-2 --region us-east4

Ausgabe:

Created [https://www.googleapis.com/compute/v1/projects/<Project ID>/regions/us-east4/addresses/nat-address-1].
Created [https://www.googleapis.com/compute/v1/projects/<Project ID>/regions/us-east4/addresses/nat-address-2].
Created [https://www.googleapis.com/compute/v1/projects/<Project ID>/regions/us-east4/addresses/producer-address-1].
Created [https://www.googleapis.com/compute/v1/projects/<Project ID>/regions/us-east4/addresses/producer-address-2].

Füllen Sie die IP-Adressen aus, die als Umgebungsvariablen reserviert wurden.

export natip1=`gcloud compute addresses list --filter name:nat-address-1 --format="get(address)"`
export natip2=`gcloud compute addresses list --filter name:nat-address-2 --format="get(address)"`
export producerip1=`gcloud compute addresses list --filter name:producer-address-1 --format="get(address)"`
export producerip2=`gcloud compute addresses list --filter name:producer-address-2 --format="get(address)"`

Es wird keine Ausgabe erwartet, aber es wird bestätigt, dass die Adressen korrekt ausgefüllt wurden. Lassen Sie uns die Werte aller Umgebungsvariablen ausgeben.

env | egrep '^(nat|producer)ip[1-3]'

Ausgabe:

producerip1=<Actual Producer IP 1>
producerip2=<Actual Producer IP 2>
natip1=<NAT IP 1>
natip2=<NAT IP 2>

5. Producer-VPC und -Instanzeinrichtung.

Jetzt erstellen wir die Ressourcen für die Erstellerressourcen. Die Instanzen, die in der Producer-VPC ausgeführt werden, bieten den mit dem Internet verbundenen Dienst über die beiden öffentlichen IP-Adressen "Producer-address-1" an. und "Producer-address-2" .

Zuerst erstellen wir die VPC. In Cloud Shell:

gcloud compute networks create producer-vpc --subnet-mode custom

Ausgabe:

Created [https://www.googleapis.com/compute/v1/projects/<Project-ID>/global/networks/producer-vpc].
NAME      SUBNET_MODE  BGP_ROUTING_MODE  IPV4_RANGE  GATEWAY_IPV4
producer-vpc  CUSTOM       REGIONAL

Instances on this network will not be reachable until firewall rules
are created. As an example, you can allow all internal traffic between
instances as well as SSH, RDP, and ICMP by running:

$ gcloud compute firewall-rules create <FIREWALL_NAME> --network producer-vpc --allow tcp,udp,icmp --source-ranges <IP_RANGE>
$ gcloud compute firewall-rules create <FIREWALL_NAME> --network producer-vpc --allow tcp:22,tcp:3389,icmp

Als Nächstes erstellen wir das Subnetz in us-east4. In Cloud Shell:

gcloud compute networks subnets create prod-net-e4 \
   --network producer-vpc --range 10.0.0.0/24 --region us-east4

Ausgabe:

Created [https://www.googleapis.com/compute/v1/projects/<Project ID>/regions/us-east4/subnetworks/prod-net-e4].
NAME         REGION    NETWORK       RANGE        STACK_TYPE  IPV6_ACCESS_TYPE  IPV6_CIDR_RANGE  EXTERNAL_IPV6_CIDR_RANGE
prod-net-e4  us-east4  producer-vpc  10.0.0.0/24  IPV4_ONLY

Als Nächstes erstellen wir VPC-Firewallregeln, damit die NAT-IP-Adressen die Producer-Instanzen an Port 8080 erreichen können.

Führen Sie für die erste Regel in Cloud Shell folgende Schritte aus:

gcloud compute firewall-rules create producer-allow-80 \
  --network producer-vpc --allow tcp:80 \
  --source-ranges $natip1,$natip2

Ausgabe:

Creating firewall...⠹Created [https://www.googleapis.com/compute/v1/projects/<Project ID>/global/firewalls/producer-allow-80].
Creating firewall...done.
NAME                 NETWORK       DIRECTION  PRIORITY  ALLOW     DENY  DISABLED
producer-allow-80    producer-vpc  INGRESS    1000      tcp:80          False

Im nächsten Schritt erstellen Sie die beiden Producer-Instanzen.

Die Producer-Instanzen führen eine einfache nginx-Proxy-Bereitstellung aus.

Um die Instanzen schnell mit der erforderlichen Software bereitzustellen, erstellen wir die Instanzen mit einem Startskript, das nginx mithilfe des Debian APT-Paketmanagers installiert.

Damit Sie NAT-Regeln schreiben können, stellen wir jeder Instanz eine andere reservierte IP-Adresse zur Verfügung.

Erstellen Sie die erste Instanz. In Cloud Shell:

gcloud compute instances create producer-instance-1 \
--zone=us-east4-a --machine-type=e2-medium \
--network-interface=address=producer-address-1,network-tier=PREMIUM,subnet=prod-net-e4 \
--metadata startup-script="#! /bin/bash
sudo apt update
sudo apt install -y nginx
mkdir /var/www/html/nginx/
cat <<EOF > /var/www/html/nginx/index.html
<html><body><h1>This is producer instance 1</h1>
</body></html>
EOF"

Ausgabe:

Created [https://www.googleapis.com/compute/v1/projects/<Project ID>/zones/us-east4-a/instances/producer-instance-1].
NAME                 ZONE        MACHINE_TYPE  PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP    STATUS
producer-instance-1  us-east4-a  e2-medium                  10.0.0.2     <Producer IP1>  RUNNING

Erstellen Sie dann die zweite Instanz. In Cloud Shell:

gcloud compute instances create producer-instance-2 \
--zone=us-east4-a --machine-type=e2-medium \
--network-interface=address=producer-address-2,network-tier=PREMIUM,subnet=prod-net-e4 \
--metadata startup-script="#! /bin/bash
sudo apt update
sudo apt install -y nginx
mkdir /var/www/html/nginx/
cat <<EOF > /var/www/html/nginx/index.html
<html><body><h1>This is producer instance 2</h1>
</body></html>
EOF"

Ausgabe:

Created [https://www.googleapis.com/compute/v1/projects/<Project ID>/zones/us-east4-a/instances/producer-instance-2].
NAME                 ZONE        MACHINE_TYPE  PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP    STATUS
producer-instance-2  us-east4-a  e2-medium                  10.0.0.3     <Producer IP2>  RUNNING

6. VPC für Nutzer, Cloud NAT und Instanzen einrichten

Nachdem Sie den Producer-Dienst erstellt haben, können Sie nun die Nutzer-VPC und das zugehörige Cloud NAT-Gateway erstellen.

Nachdem Sie die VPC und das Subnetz erstellt haben, fügen Sie eine einfache Firewallregel für eingehenden Traffic hinzu, um IAP für TCP-Quell-IP-Bereiche zuzulassen. Dadurch können wir mit gcloud direkt eine SSH-Verbindung zu den Nutzerinstanzen herstellen.

Wir erstellen dann ein einfaches Cloud NAT-Gateway im manuellen Zuweisungsmodus und die reservierte Adresse „nat-address-1“ die damit verknüpft sind. In den nachfolgenden Teilen des Codelabs aktualisieren wir die Gateway-Konfiguration, um die dynamische Portzuweisung zu aktivieren, und fügen später benutzerdefinierte Regeln hinzu.

Zuerst erstellen wir die VPC. In Cloud Shell:

gcloud compute networks create consumer-vpc --subnet-mode custom

Ausgabe:

Created [https://www.googleapis.com/compute/v1/projects/<Project ID>/global/networks/consumer-vpc].
NAME          SUBNET_MODE  BGP_ROUTING_MODE  IPV4_RANGE  GATEWAY_IPV4
consumer-vpc  CUSTOM       REGIONAL

Instances on this network will not be reachable until firewall rules
are created. As an example, you can allow all internal traffic between
instances as well as SSH, RDP, and ICMP by running:

$ gcloud compute firewall-rules create <FIREWALL_NAME> --network consumer-vpc --allow tcp,udp,icmp --source-ranges <IP_RANGE>
$ gcloud compute firewall-rules create <FIREWALL_NAME> --network consumer-vpc --allow tcp:22,tcp:3389,icmp

Als Nächstes erstellen wir ein Subnetz in us-east4. In Cloud Shell:

gcloud compute networks subnets create cons-net-e4 \
   --network consumer-vpc --range 10.0.0.0/24 --region us-east4

Ausgabe:

Created [https://www.googleapis.com/compute/v1/projects/<Project ID>/regions/us-east4/subnetworks/cons-net-e4].
NAME         REGION    NETWORK       RANGE        STACK_TYPE  IPV6_ACCESS_TYPE  IPV6_CIDR_RANGE  EXTERNAL_IPV6_CIDR_RANGE
cons-net-e4  us-east4  consumer-vpc  10.0.0.0/24  IPV4_ONLY

Als Nächstes erstellen wir VPC-Firewallregeln, damit Adressen von IAP-Bereichen die Nutzerinstanzen an Port 22 erreichen können.

Führen Sie als erste Firewallregel folgenden Befehl in Cloud Shell aus:

gcloud compute firewall-rules create consumer-allow-iap \
  --network consumer-vpc --allow tcp:22 \
  --source-ranges 35.235.240.0/20

Ausgabe:

Creating firewall...⠹Created [https://www.googleapis.com/compute/v1/projects/<Project-ID>/global/firewalls/consumer-allow-iap].
Creating firewall...done.
NAME                 NETWORK       DIRECTION  PRIORITY  ALLOW     DENY  DISABLED
consumer-allow-iap  consumer-vpc  INGRESS    1000      tcp:22        False

Bevor Sie ein NAT-Gateway erstellen, müssen Sie eine Cloud Router-Instanz erstellen. Wir verwenden eine private ASN-Nummer, die für die Aktivitäten dieses Labs jedoch nicht relevant ist. In Cloud Shell:

gcloud compute routers create consumer-cr \
--region=us-east4 --network=consumer-vpc \
 --asn=65501

Ausgabe:

Creating router [consumer-cr]...done.
NAME         REGION       NETWORK
consumer-cr  us-east4  consumer-vpc

Erstellen Sie dann die NAT-Gateway-Instanz. In Cloud Shell:

gcloud compute routers nats create consumer-nat-gw \
    --router=consumer-cr \
    --router-region=us-east4 \
    --nat-all-subnet-ip-ranges \
    --nat-external-ip-pool=nat-address-1

Ausgabe:

Creating NAT [consumer-nat-gw] in router [consumer-cr]...done.

Standardmäßig wird das Cloud NAT-Gateway mit minPortsPerVm auf 64 erstellt

Erstellen Sie die Testinstanzen für Nutzer. Die reservierten Producer-IP-Adressen werden hier eingetragen, damit wir später in der Instanz darauf verweisen können. In Cloud Shell:

gcloud compute instances create consumer-instance-1 --zone=us-east4-a \
--machine-type=e2-medium --network-interface=subnet=cons-net-e4,no-address \
--metadata=producer-service-ip1=$producerip1,producer-service-ip2=$producerip2

gcloud compute instances create consumer-instance-2 --zone=us-east4-a \
--machine-type=e2-medium --network-interface=subnet=cons-net-e4,no-address \
--metadata=producer-service-ip1=$producerip1,producer-service-ip2=$producerip2

Ausgabe:

Created [https://www.googleapis.com/compute/v1/projects/<Project ID>/zones/us-east4-a/instances/consumer-instance-1].
NAME                ZONE        MACHINE_TYPE  PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP  STATUS
consumer-instance-1  us-east4-a  e2-medium                  10.0.0.2                  RUNNING

Created [https://www.googleapis.com/compute/v1/projects/<Project ID>/zones/us-east4-a/instances/consumer-instance-2].
NAME                ZONE        MACHINE_TYPE  PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP  STATUS
consumer-instance-2  us-east4-a  e2-medium                  10.0.0.3                  RUNNING

7. Cloud NAT-Standardverhalten prüfen

An diesem Punkt verwenden die Nutzerinstanzen das Cloud NAT-Standardverhalten, das dieselbe reservierte IP-Adresse „nat-address-1“ verwendet für die Kommunikation mit allen externen Adressen. Bei Cloud NAT ist die DPA noch nicht aktiviert.

Führen Sie den folgenden Befehl aus, um zu prüfen, welche Ports Cloud NAT den Nutzerinstanzen zugewiesen hat.

gcloud  compute routers get-nat-mapping-info consumer-cr --region=us-east4

Beispielausgabe:

---
instanceName: consumer-instance-1
interfaceNatMappings:
- natIpPortRanges:
  - <NAT Consumer IP1>:1024-1055
  numTotalDrainNatPorts: 0
  numTotalNatPorts: 32
  sourceAliasIpRange: ''
  sourceVirtualIp: 10.0.0.2
- natIpPortRanges:
  - <NAT Consumer IP1>:32768-32799
  numTotalDrainNatPorts: 0
  numTotalNatPorts: 32
  sourceAliasIpRange: ''
  sourceVirtualIp: 10.0.0.2
---
instanceName: consumer-instance-2
interfaceNatMappings:
- natIpPortRanges:
  - <NAT Address IP1>:1056-1087
  numTotalDrainNatPorts: 0
  numTotalNatPorts: 32
  sourceAliasIpRange: ''
  sourceVirtualIp: 10.0.0.3
- natIpPortRanges:
  - <NAT Address IP1>:32800-32831
  numTotalDrainNatPorts: 0
  numTotalNatPorts: 32
  sourceAliasIpRange: ''
  sourceVirtualIp: 10.0.0.3

Wie Sie der obigen Ausgabe entnehmen können, sind Cloud NAT 64 Ports pro Instanz von derselben externen IP-Adresse zugewiesen. nat-address-1

Lassen Sie uns prüfen, wie viele Verbindungen parallel geöffnet werden können, bevor Sie DPA aktivieren.

Stellen Sie eine SSH-Verbindung zur ersten Nutzerinstanz her. In Cloud Shell:

gcloud compute ssh consumer-instance-1 --zone=us-east4-a

Sie sollten sich jetzt in der Instanz-Shell befinden.

Beispielausgabe (der Einfachheit halber vollständige Ausgabe gekürzt)

External IP address was not found; defaulting to using IAP tunneling.
...
...
<username>@consumer-instance-1:~$

Rufen Sie in der Nutzerinstanz zuerst beide Producer-IP-Adressen ab und geben Sie sie als Umgebungsvariablen ein.

export producerip1=`curl -s "http://metadata.google.internal/computeMetadata/v1/instance/attributes/producer-service-ip1" -H "Metadata-Flavor: Google"`

export producerip2=`curl -s "http://metadata.google.internal/computeMetadata/v1/instance/attributes/producer-service-ip2" -H "Metadata-Flavor: Google"`

Versuchen Sie dann, mit dem curl-Befehl beide Producer-Instanzen zu erreichen, um sicherzustellen, dass wir sie erfolgreich erreichen können.

<username>@consumer-instance-1:~$ curl http://$producerip1/nginx/
<html><body><h1>This is producer instance 1</h1>
</body></html>
<username>@consumer-instance-1:~$ curl http://$producerip2/nginx/
<html><body><h1>This is producer instance 2</h1>
</body></html>

Versuchen wir nun, viele parallele Verbindungen zu einer der Producer-Instanzen zu erstellen, indem wir curl über eine Schleife ausführen. Denken Sie daran, dass Cloud NAT die Wiederverwendung geschlossener Sockets für 2 Minuten nicht zulässt. Solange alle Verbindungsversuche innerhalb von zwei Minuten durchlaufen werden können, können wir also parallele Verbindungen auf diese Weise simulieren.

Führen Sie in der SSH-Sitzung der Instanz den folgenden Befehl aus:

while true; do for i in {1..64}; do curl -s -o /dev/null --connect-timeout 5 http://$producerip1/nginx/; if [ $? -ne 0 ] ; then echo -e "\nConnection # $i failed" ; else echo -en "\rConnection # $i successful"; fi; done; echo -e "\nLoop Done, Sleeping for 150s"; sleep 150; done

Sie würden erwarten, dass Sie erfolgreich 64 parallele Verbindungen öffnen können und das Skript Folgendes ausgibt:

Connection # 64 successful

Loop Done, Sleeping for 150s
Connection # 64 successful

Loop Done, Sleeping for 150s

Warten Sie zunächst zwei Minuten, bis alle alten Sockets gelöscht sind. Passen Sie dann denselben Einzeiler wie folgt an und wiederholen Sie den Test.

while true; do for i in {1..70}; do curl -s -o /dev/null --connect-timeout 5 http://$producerip1/nginx/; if [ $? -ne 0 ] ; then echo -e "\nConnection # $i failed" ; else echo -en "\rConnection # $i successful"; fi; done; echo -e "\nLoop Done, Sleeping for 150s"; sleep 150; done

Sie würden jetzt die folgende Ausgabe erwarten

Connection # 64 successful
Connection # 65 failed
Connection # 66 failed
Connection # 67 failed
Connection # 68 failed
Connection # 69 failed
Connection # 70 failed

Loop Done, Sleeping for 150s

Dies bedeutet, dass die ersten 64 Verbindungen erfolgreich waren, die verbleibenden 6 Verbindungen jedoch aufgrund der Nichtverfügbarkeit von Ports fehlgeschlagen sind.

Lassen Sie uns etwas unternehmen. Beenden Sie dann die SSH-Shell und aktivieren Sie die DPA im folgenden Abschnitt.

8. Zusatz zur Datenverarbeitung aktivieren und Verhalten validieren

Führen Sie den folgenden gcloud-Befehl aus, um DPA zu aktivieren und die minimale Portzuweisung pro VM auf 64 und die maximale Portzuweisung auf 1.024 festzulegen.

gcloud alpha compute routers nats update consumer-nat-gw --router=consumer-cr \
--region=us-east4 --min-ports-per-vm=64 --max-ports-per-vm=1024 \
--enable-dynamic-port-allocation

Dadurch wird Folgendes ausgegeben:

Updating nat [consumer-nat-gw] in router [consumer-cr]...done.

Führen Sie nun get-nat-mapping-info noch einmal aus, um zu prüfen, ob beiden Instanzen immer noch nur 64 Ports zugewiesen sind.

gcloud  compute routers get-nat-mapping-info consumer-cr --region=us-east4

Beispielausgabe (zur Kürze gekürzt)

---
instanceName: consumer-instance-1
...
  - <NAT Consumer IP1>:1024-1055
  numTotalNatPorts: 32
...
- natIpPortRanges:
  - <NAT Consumer IP1>:32768-32799
  numTotalNatPorts: 32
...
---
instanceName: consumer-instance-2
...
  - <NAT Address IP1>:1056-1087
  numTotalNatPorts: 32
...
  - <NAT Address IP1>:32800-32831
  numTotalNatPorts: 32
...

An den Portzuweisungen hat sich nicht viel geändert, da die Instanz noch keine Ports aktiv verwendet.

Stellen Sie eine SSH-Verbindung zur Instanz her:

gcloud compute ssh consumer-instance-1 --zone=us-east4-a

Exportieren Sie die Umgebungsvariablen der Ersteller-IP noch einmal.

export producerip1=`curl -s "http://metadata.google.internal/computeMetadata/v1/instance/attributes/producer-service-ip1" -H "Metadata-Flavor: Google"`

export producerip2=`curl -s "http://metadata.google.internal/computeMetadata/v1/instance/attributes/producer-service-ip2" -H "Metadata-Flavor: Google"`

Und führen Sie die vorherige Schleife noch einmal aus, um parallele Verbindungen zu simulieren:

while true; do for i in {1..70}; do curl -s -o /dev/null --connect-timeout 5 http://$producerip1/nginx/; if [ $? -ne 0 ] ; then echo -e "\nConnection # $i failed" ; else echo -en "\rConnection # $i successful"; fi; done; echo -e "\nLoop Done, Sleeping for 150s"; sleep 150; done

Jetzt sollten wir die folgende Ausgabe sehen:

Connection # 64 successful
Connection # 65 failed

Connection # 66 failed
Connection # 70 successful
Loop Done, Sleeping for 150s

Was ist also passiert? Cloud NAT erhöht die Portzuweisung bei steigender Portnutzung. Die Programmierung auf der gesamten Netzwerkebene nimmt jedoch einige Zeit in Anspruch. Daher treten 1–3 Zeitüberschreitungen auf, bevor die restlichen Verbindungsversuche erfolgreich abgeschlossen werden.

Wir haben ein aggressives Zeitlimit für curl (5 Sekunden) festgelegt, aber Anwendungen mit längeren Zeitlimits sollten in der Lage sein, Verbindungen erfolgreich herzustellen, während die DPA die Portzuweisungen erhöht.

Dieses Anstiegsverhalten wird deutlicher sichtbar, wenn wir den Loop für 1.024 Verbindungsversuche wie diese ausführen.

while true; do for i in {1..1024}; do curl -s -o /dev/null --connect-timeout 5 http://$producerip1/nginx/; if [ $? -ne 0 ] ; then echo -e "\nConnection # $i failed" ; else echo -en "\rConnection # $i successful"; fi; done; echo -e "\nLoop Done, Sleeping for 150s"; sleep 150; done

Wir erwarten nun die folgende Ausgabe

Connection # 64 successful
Connection # 65 failed

Connection # 66 failed
Connection # 129 successful
Connection # 130 failed

Connection # 131 failed
Connection # 258 successful
Connection # 259 failed

Connection # 260 failed
Connection # 515 successful
Connection # 516 failed

Connection # 1024 successful
Loop Done, Sleeping for 150s

Da Cloud NAT Ports in Zweierpotenzen zuweist, wodurch sich die Zuweisungen in jedem Schritt verdoppeln, werden die Verbindungszeitlimits um die Potenz von 2 zwischen 64 und 1.024 hervorgehoben.

Da maxPortsPerVM auf 1.024 gesetzt wurde, gehen wir davon aus, nicht mehr als 1.024 Verbindungen herstellen zu können. Das können wir testen, indem wir die curl-Schleife mit einer höheren Anzahl als 1024 noch einmal ausführen (nachdem Sie zwei Minuten gewartet haben, um veraltete Ports zurückzusetzen).

while true; do for i in {1..1035}; do curl -s -o /dev/null --connect-timeout 5 http://$producerip1/nginx/; if [ $? -ne 0 ] ; then echo -e "\nConnection # $i failed" ; else echo -en "\rConnection # $i successful"; fi; done; echo -e "\nLoop Done, Sleeping for 150s"; sleep 150; done

Wie erwartet, zeigt die Ausgabe, dass Verbindungen nach 1024 ausfallen.

<truncated output>
...
Connection # 1028 successful
Connection # 1029 failed
Connection # 1030 failed
Connection # 1031 failed
Connection # 1032 failed
Connection # 1033 failed
Connection # 1034 failed
Connection # 1035 failed
...
Loop Done, Sleeping for 150s

Durch das Setzen von maxPortsPerVM auf 1.024 wurde Cloud NAT angewiesen, Portzuweisungen pro VM niemals über 1.024 hinaus zu skalieren.

Wenn wir die SSH-Sitzung beenden und get-nat-mapping-info schnell genug ausführen, können wir sehen, dass die zusätzlichen Ports zugewiesen sind.

gcloud  compute routers get-nat-mapping-info consumer-cr --region=us-east4

Sehen Sie sich die folgende Ausgabe an:

---
instanceName: consumer-instance-1
interfaceNatMappings:
- natIpPortRanges:
  - <NAT Address IP1>:1024-1055
  - <NAT Address IP1>1088-1119
  -<NAT Address IP1>:1152-1215
  - <NAT Address IP1>:1280-1407
  - <NAT Address IP1>:1536-1791
  numTotalDrainNatPorts: 0
  numTotalNatPorts: 512
  sourceAliasIpRange: ''
  sourceVirtualIp: 10.0.0.2
- natIpPortRanges:
  - <NAT Address IP1>:32768-32799
  - <NAT Address IP1>:32832-32863
  - <NAT Address IP1>:32896-32959
  - <NAT Address IP1>:33024-33151
  - <NAT Address IP1>:33536-33791
  numTotalDrainNatPorts: 0
  numTotalNatPorts: 512
  sourceAliasIpRange: ''
  sourceVirtualIp: 10.0.0.2
---
instanceName: consumer-instance-2
interfaceNatMappings:
- natIpPortRanges:
  - <NAT Address IP1>:1056-1087
  numTotalDrainNatPorts: 0
  numTotalNatPorts: 32
  sourceAliasIpRange: ''
  sourceVirtualIp: 10.0.0.3
- natIpPortRanges:
  - <NAT Address IP1>:32800-32831
  numTotalDrainNatPorts: 0
  numTotalNatPorts: 32
  sourceAliasIpRange: ''
  sourceVirtualIp: 10.0.0.3

Wie Sie sehen, hat consumer-instance-1 1.024 Ports zugewiesen, consumer-instance-2 aber nur 64 Ports. Vor der DPA war dies nicht einfach möglich und unterstreicht genau, welche Vorteile DPA für Cloud NAT bietet.

Wenn Sie zwei Minuten warten, bevor Sie den Befehl get-nat-mapping-info noch einmal ausführen, werden Sie feststellen, dass consumer-instance-1 wieder den Mindestwert von 64 zugewiesenen Ports erreicht hat. Veranschaulicht nicht nur, dass DPA die Portzuweisungen erhöhen, sondern auch freigeben kann, wenn sie nicht verwendet werden, damit sie von anderen Instanzen hinter demselben NAT-Gateway genutzt werden können.

9. Cloud NAT-Regeln mit DPA testen

Vor Kurzem haben wir auch NAT-Regelfunktionen für Cloud NAT veröffentlicht, mit denen Kunden Regeln erstellen können, die bestimmte NAT-IP-Adressen für bestimmte externe Ziele verwenden. Weitere Informationen finden Sie auf der Dokumentationsseite zu NAT-Regeln.

In dieser Übung beobachten wir die Interaktion zwischen der Datenschutzaufsichtsbehörde und den NAT-Regeln. Definieren wir zuerst eine NAT-Regel zur Verwendung von nat-address-2 beim Zugriff auf producer-address-2.

Führen Sie den folgenden gcloud-Befehl aus. Dadurch wird die NAT-Regel mithilfe von

gcloud alpha compute routers nats rules create 100 \
 --match='destination.ip == "'$producerip2'"' \
 --source-nat-active-ips=nat-address-2 --nat=consumer-nat-gw \
 --router=consumer-cr --router-region=us-east4

Sie sollten folgende Ausgabe erwarten

Updating nat [consumer-nat-gw] in router [consumer-cr]...done.

Lassen Sie get-nat-mapping-info jetzt noch einmal ausführen, um die Auswirkungen der neuen NAT-Regel zu sehen.

gcloud alpha compute routers get-nat-mapping-info consumer-cr --region=us-east4

Dadurch sollte Folgendes ausgegeben werden:

---
instanceName: consumer-instance-1
interfaceNatMappings:
- natIpPortRanges:
  - <NAT Address IP1>:1024-1055
  numTotalDrainNatPorts: 0
  numTotalNatPorts: 32
  ruleMappings:
  - natIpPortRanges:
    - <NAT Address IP2>:1024-1055
    numTotalDrainNatPorts: 0
    numTotalNatPorts: 32
    ruleNumber: 100
  sourceAliasIpRange: ''
  sourceVirtualIp: 10.0.0.2
- natIpPortRanges:
  - <NAT Address IP1>:32768-32799
  numTotalDrainNatPorts: 0
  numTotalNatPorts: 32
  ruleMappings:
  - natIpPortRanges:
    - <NAT Address IP2>:32768-32799
    numTotalDrainNatPorts: 0
    numTotalNatPorts: 32
    ruleNumber: 100
  sourceAliasIpRange: ''
  sourceVirtualIp: 10.0.0.2

Wie Sie sehen, haben wir jetzt speziell für nat-address-2 in der ruleMappings-Hierarchie zusätzliche Ports zugewiesen (ebenfalls am angegebenen Minimum 64).

Was passiert also, wenn eine Instanz viele Verbindungen zu dem durch die NAT-Regel angegebenen Ziel öffnet? Das lässt sich ganz einfach herausfinden.

Stellen Sie eine SSH-Verbindung zur Instanz her:

gcloud compute ssh consumer-instance-1 --zone=us-east4-a

Exportieren Sie die Umgebungsvariablen der Ersteller-IP noch einmal.

export producerip1=`curl -s "http://metadata.google.internal/computeMetadata/v1/instance/attributes/producer-service-ip1" -H "Metadata-Flavor: Google"`

export producerip2=`curl -s "http://metadata.google.internal/computeMetadata/v1/instance/attributes/producer-service-ip2" -H "Metadata-Flavor: Google"`

Und jetzt führen wir die curl-Schleife dieses Mal noch einmal für producerip2 aus.

while true; do for i in {1..1024}; do curl -s -o /dev/null --connect-timeout 5 http://$producerip2/nginx/; if [ $? -ne 0 ] ; then echo -e "\nConnection # $i failed" ; else echo -en "\rConnection # $i successful"; fi; done; echo -e "\nLoop Done, Sleeping for 150s"; sleep 150; done

Die Ausgabe sollte in etwa so aussehen:

Connection # 64 successful
Connection # 65 failed

Connection # 66 failed
Connection # 129 successful
Connection # 130 failed

Connection # 131 failed
Connection # 258 successful
Connection # 259 failed

Connection # 260 failed
Connection # 515 successful
Connection # 516 failed

Connection # 1024 successful
Loop Done, Sleeping for 150s

Im Grunde wird der vorherige Test gespiegelt. Beenden wir die SSH-Sitzung der Instanz und sehen uns noch einmal die nat-Zuordnungen an.

gcloud alpha compute routers get-nat-mapping-info consumer-cr --region=us-east4

Dadurch sollte Folgendes ausgegeben werden:

---
instanceName: consumer-instance-1
interfaceNatMappings:
- natIpPortRanges:
  - <NAT Address IP1>:1024-1055
  numTotalDrainNatPorts: 0
  numTotalNatPorts: 32
  ruleMappings:
  - natIpPortRanges:
    - <NAT Address IP2>:1024-1055
    - <NAT Address IP2>:1088-1119
    - <NAT Address IP2>:1152-1215
    - <NAT Address IP2>:1280-1407
    - <NAT Address IP2>:1536-1791
    numTotalDrainNatPorts: 0
    numTotalNatPorts: 512
    ruleNumber: 100
  sourceAliasIpRange: ''
  sourceVirtualIp: 10.0.0.2
- natIpPortRanges:
  - <NAT Address IP1>:32768-32799
  numTotalDrainNatPorts: 0
  numTotalNatPorts: 32
  ruleMappings:
  - natIpPortRanges:
    - <NAT Address IP2>:32768-32799
    - <NAT Address IP2>:32832-32863
    - <NAT Address IP2>:32896-32959
    - <NAT Address IP2>:33024-33151
    - <NAT Address IP2>:33280-33535
    numTotalDrainNatPorts: 0
    numTotalNatPorts: 512
    ruleNumber: 100
  sourceAliasIpRange: ''
  sourceVirtualIp: 10.0.0.2
---
instanceName: consumer-instance-2
interfaceNatMappings:
- natIpPortRanges:
  - <NAT Address IP1>:1056-1087
  numTotalDrainNatPorts: 0
  numTotalNatPorts: 32
  ruleMappings:
  - natIpPortRanges:
    - <NAT Address IP2>:1056-1087
    numTotalDrainNatPorts: 0
    numTotalNatPorts: 32
    ruleNumber: 100
  sourceAliasIpRange: ''
  sourceVirtualIp: 10.0.0.3
- natIpPortRanges:
  - <NAT Address IP1>:32800-32831
  numTotalDrainNatPorts: 0
  numTotalNatPorts: 32
  ruleMappings:
  - natIpPortRanges:
    - <NAT Address IP2>:32800-32831
    numTotalDrainNatPorts: 0
    numTotalNatPorts: 32
    ruleNumber: 100
  sourceAliasIpRange: ''
  sourceVirtualIp: 10.0.0.3

---
instanceName: consumer-instance-1
interfaceNatMappings:
- natIpPortRanges:
  - <NAT Address IP1>:1024-1055
  numTotalDrainNatPorts: 0
  numTotalNatPorts: 32
  ruleMappings:
  - natIpPortRanges:
    - <NAT Address IP2>:1024-1055
    numTotalDrainNatPorts: 0
    numTotalNatPorts: 32
    ruleNumber: 100
  sourceAliasIpRange: ''
  sourceVirtualIp: 10.0.0.2
- natIpPortRanges:
  - <NAT Address IP1>:32768-32799
  numTotalDrainNatPorts: 0
  numTotalNatPorts: 32
  ruleMappings:
  - natIpPortRanges:
    - <NAT Address IP2>:32768-32799
    numTotalDrainNatPorts: 0
    numTotalNatPorts: 32
    ruleNumber: 100
  sourceAliasIpRange: ''
  sourceVirtualIp: 10.0.0.2

Wie Sie oben sehen können, sind der Standard-NAT-IP von consumer-instance-1 ( die IP für nat-address-1) immer noch nur 64 Ports zugewiesen, während der IP-Adresse der NAT-Regel (IP für nat-address-2) 1.024 Ports zugewiesen sind. Währenddessen behielt consumer-instance-2 die Standardzuweisungen von 64 Ports für alle NAT-IP-Adressen bei.

Als Übung können Sie auch die umgekehrte Schreibweise testen. Lassen Sie Cloud NAT die Zuweisung aller zusätzlichen Ports aufheben, führen Sie dann die curl-Schleife für producerip1 aus und beobachten Sie die Auswirkungen auf die Ausgabe von get-nat-mapping-info

10. Bereinigungsschritte

Löschen Sie alle mit diesem Codelab verknüpften Ressourcen, um wiederkehrende Gebühren zu vermeiden.

Löschen Sie zuerst alle Instanzen.

In Cloud Shell:

gcloud compute instances delete consumer-instance-1 consumer-instance-2 \
 producer-instance-1 producer-instance-2 \
 --zone us-east4-a --quiet

Erwartete Ausgabe :

Deleted [https://www.googleapis.com/compute/v1/projects/<Project Id>/zones/us-east4-a/instances/consumer-instance-1].
Deleted [https://www.googleapis.com/compute/v1/projects/<Project Id>/zones/us-east4-a/instances/consumer-instance-2].
Deleted [https://www.googleapis.com/compute/v1/projects/<Project Id>/zones/us-east4-a/instances/producer-instance-1].
Deleted [https://www.googleapis.com/compute/v1/projects/<Project Id>/zones/us-east4-a/instances/producer-instance-2].

Löschen Sie als Nächstes den Cloud Router. In Cloud Shell:

gcloud compute routers delete consumer-cr \
 --region us-east4 --quiet