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 hoch oder herunter. DPA wird mit minimalen und maximalen Portlimits konfiguriert, sodass die Anzahl der Ports nie unter den Mindestwert oder über den Höchstwert hinaus skaliert wird. So können einige Instanzen hinter NAT-Gateways die Anzahl ihrer Verbindungen dynamisch erhöhen, ohne dass allen Instanzen hinter Cloud NAT mehr Ports zugewiesen werden müssen.

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

Weitere Informationen finden Sie im Dokumentationsabschnitt zur NAT-DPA .

Lerninhalte

  • Ein Cloud NAT-Gateway zur Vorbereitung auf DPA einrichten
  • Portzuweisungen ohne DPA prüfen
  • So aktivieren und konfigurieren Sie DPA für ein NAT-Gateway.
  • Auswirkungen der Datenverarbeitungsvereinbarung durch parallele Ausgänge beobachten
  • So fügen Sie einem NAT-Gateway mit aktivierter DPA NAT-Regeln hinzu.
  • So sehen Sie das Verhalten von DPA mit Regeln, indem Sie ausgehende Verbindungen zu mehreren Zielen herstellen.

Voraussetzungen

  • Grundkenntnisse hinsichtlich der Google Compute Engine
  • Grundkenntnisse in den Bereichen Netzwerk und TCP/IP
  • Grundkenntnisse zu Unix/Linux-Befehlszeilen
  • Es ist hilfreich, wenn Sie bereits eine Einführung in die Netzwerkfunktionen von Google Cloud absolviert haben, z. B. das Lab Networking in Google Cloud.
  • Ein Google Cloud-Projekt mit aktiviertem „Alphazugriff“.
  • Grundlagen von Cloud NAT.

2. Google Cloud Console und Cloud Shell verwenden

In diesem Lab verwenden wir sowohl die Google Cloud Console als auch Cloud Shell, um mit GCP zu interagieren.

Google Cloud Console

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

75eef5f6fd6d7e41.png

Umgebung zum selbstbestimmten Lernen einrichten

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

96a9c957bc475304.png

b9a10ebdf5b5a448.png

a1e3c01a38fa61c2.png

  • Der Projektname ist der Anzeigename für die Teilnehmer dieses Projekts. Es handelt sich um einen String, der nicht von Google APIs verwendet wird und den Sie jederzeit aktualisieren können.
  • Die Projekt-ID muss für alle Google Cloud-Projekte eindeutig sein und ist unveränderlich (kann nach der Festlegung nicht mehr geändert werden). In der Cloud Console wird automatisch ein eindeutiger String generiert. Normalerweise ist es nicht wichtig, wie dieser aussieht. In den meisten Codelabs müssen Sie auf die Projekt-ID verweisen (die in der Regel als PROJECT_ID angegeben wird). Wenn Ihnen die ID nicht gefällt, können Sie eine andere zufällige ID generieren oder eine eigene ID ausprobieren und sehen, ob sie verfügbar ist. Nachdem das Projekt erstellt wurde, wird es „eingefroren“.
  • Es gibt einen dritten Wert, die Projektnummer, die von einigen APIs verwendet wird. Weitere Informationen zu diesen drei Werten
  1. Als Nächstes müssen Sie die Abrechnung in der Cloud Console aktivieren, um Cloud-Ressourcen/-APIs verwenden zu können. Die Durchführung dieses Codelabs sollte keine oder nur geringe Kosten verursachen. Wenn Sie Ressourcen herunterfahren möchten, damit nach Abschluss dieses Codelabs keine Gebühren anfallen, folgen Sie den Bereinigungsanweisungen am Ende des Codelabs. Neue Nutzer von Google Cloud kommen für das Programm für kostenlose Testversionen mit einem Guthaben von 300$ infrage.

Cloud Shell starten

Während Sie Google Cloud von Ihrem Laptop aus per Fernzugriff nutzen können, wird in diesem Codelab Google Cloud Shell verwendet, 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:

bce75f34b2c53987.png

Die Bereitstellung und Verbindung mit der Umgebung sollte nur wenige Augenblicke dauern. Anschließend sehen Sie in etwa Folgendes:

f6ef2b5f13479f3a.png

Diese virtuelle Maschine verfügt über sämtliche Entwicklertools, die Sie benötigen. Sie bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und läuft in Google Cloud, was die Netzwerkleistung und Authentifizierung erheblich verbessert. Für dieses Lab benötigen Sie lediglich einen Browser.

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 und zwei Consumer-Instanzen. Nachdem Sie das Standardverhalten von Cloud NAT validiert haben, aktivieren Sie die dynamische Portzuweisung und validieren deren Verhalten. Schließlich konfigurieren Sie auch NAT-Regeln und beobachten die Interaktion zwischen DPA und NAT-Regeln.

Übersicht über die Netzwerkarchitektur:

a21caa6c333909d8.png

4. Externe IP-Adressen reservieren

Reservieren wir alle externen IP-Adressen, die in diesem Lab verwendet werden sollen. So können Sie alle relevanten NAT- und Firewallregeln sowohl im VPC des Nutzers als auch im VPC des Erstellers schreiben.

Über 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 reservierten IP-Adressen als Umgebungsvariablen ein.

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 Sie können prüfen, ob die Adressen richtig eingetragen 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. Ersteller-VPC und Instanzen einrichten.

Wir erstellen jetzt die Ressourcen für die Producer-Ressourcen. Die Instanzen, die in der Ersteller-VPC ausgeführt werden, bieten den internetorientierten Dienst über zwei öffentliche IPs an: „producer-address-1“ und „producer-address-2“.

Erstellen wir zuerst die VPC. Über 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. Über 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 auf Port 8080 erreichen können.

Für die erste Regel in Cloud Shell:

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

Als Nächstes erstellen Sie die beiden Producer-Instanzen.

Auf den Producer-Instanzen wird ein einfaches nginx-Proxy-Deployment ausgeführt.

Damit die Instanzen schnell mit der erforderlichen Software bereitgestellt werden können, erstellen wir sie mit einem Startskript, das Nginx mit dem Debian APT-Paketmanager installiert.

Damit wir NAT-Regeln schreiben können, stellen wir für jede Instanz eine andere reservierte IP-Adresse bereit.

Erstellen Sie die erste Instanz. Über 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. Über 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. Consumer-VPC, Cloud NAT und Instanzen einrichten

Nachdem Sie den Dienst des Diensterstellers erstellt haben, müssen Sie die VPC des Dienstnutzers und das zugehörige Cloud NAT-Gateway erstellen.

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

Wir erstellen dann ein einfaches Cloud NAT-Gateway im manuellen Zuweisungsmodus und die zugehörige reservierte Adresse „nat-address-1“. In den folgenden Teilen des Codelabs aktualisieren wir die Konfiguration des Gateways, um die dynamische Portzuweisung zu aktivieren und später benutzerdefinierte Regeln hinzuzufügen.

Erstellen wir zuerst die VPC. Über 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. Über 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 IAP-Bereichsadressen die Consumer-Instanzen auf Port 22 erreichen können.

Führen Sie für die erste Firewallregel den 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 wir ein NAT-Gateway erstellen können, müssen wir zuerst eine Cloud Router-Instanz erstellen. Wir verwenden eine private ASN-Nummer, die für die Aktivitäten in diesem Lab jedoch irrelevant ist. Über 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. Über 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.

Das Cloud NAT-Gateway wird standardmäßig mit minPortsPerVm auf 64 erstellt.

Erstellen Sie die Testinstanzen für Verbraucher. Wir füllen die reservierten Producer-IPs hier ein, damit wir später in der Instanz darauf verweisen können. Über 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. Standardverhalten von Cloud NAT prüfen

An diesem Punkt verwenden die Consumer-Instanzen das Standardverhalten von Cloud NAT, bei dem dieselbe reservierte IP-Adresse „nat-address-1“ für die Kommunikation mit allen externen Adressen verwendet wird. Für Cloud NAT ist die DPA noch nicht aktiviert.

Wir prüfen, welche Ports Cloud NAT für unsere Consumer-Instanzen zugewiesen hat, indem wir den folgenden Befehl ausführen.

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, hat Cloud NAT 64 Ports pro Instanz von derselben externen IP-Adresse nat-address-1 zugewiesen.

Wir prüfen, wie viele Verbindungen wir parallel öffnen können, bevor wir DPA aktivieren.

Stellen Sie eine SSH-Verbindung zur ersten Consumer-Instanz her. Über Cloud Shell:

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

Sie sollten sich jetzt in der Instanz-Shell befinden.

Beispielausgabe (vollständige Ausgabe aus Gründen der Übersichtlichkeit gekürzt)

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

Rufen wir zuerst in der Consumer-Instanz die beiden Producer-IPs ab und weisen wir sie als Umgebungsvariablen zu.

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, beide Producer-Instanzen mit „curl“ zu erreichen, um sicherzustellen, dass sie erreichbar sind.

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

Wir versuchen jetzt, viele parallele Verbindungen zu einer der Producer-Instanzen herzustellen, indem wir „curl“ in einer Schleife ausführen. Cloud NAT lässt die Wiederverwendung geschlossener Sockets für 2 Minuten nicht zu. Solange wir alle Verbindungsversuche innerhalb von 2 Minuten durchlaufen können, können wir parallele Verbindungen auf diese Weise simulieren.

Führen Sie den folgenden Befehl in der SSH-Sitzung der Instanz 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 sollten 64 parallele Verbindungen öffnen können und das Skript sollte Folgendes ausgeben:

Connection # 64 successful

Loop Done, Sleeping for 150s
Connection # 64 successful

Loop Done, Sleeping for 150s

Um zu sehen, dass wir nicht über 64 parallele Verbindungen hinausgehen können, warten Sie zuerst 2 Minuten, damit alle alten Sockets gelöscht werden. Passen Sie dann die Einzeiler-Anweisung wie folgt an und führen Sie sie noch einmal aus:

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 sollten nun die folgende Ausgabe sehen:

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

Das bedeutet, dass die ersten 64 Verbindungen erfolgreich waren, die verbleibenden 6 Verbindungen jedoch aufgrund nicht verfügbarer Ports fehlgeschlagen sind.

Dann sollten wir etwas dagegen unternehmen. Beenden Sie die SSH-Shell und aktivieren Sie DPA im nächsten Abschnitt.

8. DPA aktivieren und Verhalten validieren

Führen Sie den folgenden gcloud-Befehl aus, um DPA zu aktivieren und die Mindestportzuweisung 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 wir get-nat-mapping-info noch einmal aus, um zu bestätigen, dass beiden Instanzen weiterhin nur 64 Ports zugewiesen sind.

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

Beispielausgabe (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
...

Da die Instanz noch keine Ports aktiv verwendet, hat sich bei der Portzuweisung nicht viel geändert.

Stellen Sie wieder eine SSH-Verbindung zur Instanz her:

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

Exportieren Sie die Umgebungsvariablen für die Producer-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"`

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

Es sollte folgende Ausgabe angezeigt werden:

Connection # 64 successful
Connection # 65 failed

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

Was ist hier passiert? Bei Cloud NAT wird die Portzuweisung bei steigender Portnutzung erhöht. Es dauert jedoch einige Zeit, bis dies in der Netzwerkschicht programmiert ist. Daher sehen wir 1–3 Verbindungszeitüberschreitungen, bevor wir die restlichen Verbindungsversuche erfolgreich abschließen.

Wir haben ein aggressives Zeitlimit für curl (5 Sekunden) festgelegt. Anwendungen mit längeren Zeitlimits sollten Verbindungen jedoch erfolgreich abschließen können, während DPA die Portzuweisungen erhöht.

Dieses Verhalten lässt sich deutlicher erkennen, wenn wir die Schleife für 1.024 Verbindungsversuche 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

Es sollte nun die folgende Ausgabe angezeigt werden:

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 und die Zuweisungen in jedem Schritt im Wesentlichen verdoppelt, sehen wir die hervorgehobenen Verbindungszeitüberschreitungen um die Zweierpotenzen zwischen 64 und 1024.

Da wir maxPortsPerVM auf 1024 festgelegt haben, gehen wir davon aus, dass wir nicht mehr als 1024 Verbindungen herstellen können. Das können wir testen, indem wir die curl-Schleife mit einer höheren Anzahl als 1024 noch einmal ausführen (nachdem wir 2 Minuten gewartet haben, um alte 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, schlagen Verbindungen über 1.024 fehl.

<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 Festlegen von maxPortsPerVM auf 1024 haben wir Cloud NAT angewiesen, die Portzuweisungen pro VM niemals über 1024 hinaus zu skalieren.

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

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

consumer-instance-1 sind 1.024 Ports zugewiesen, consumer-instance-2 dagegen nur 64. Vor DPA war das nicht ohne Weiteres möglich. Das zeigt, wie leistungsstark DPA für Cloud NAT ist.

Wenn Sie 2 Minuten warten, bevor Sie den Befehl get-nat-mapping-info noch einmal ausführen, sehen Sie, dass consumer-instance-1 wieder den Mindestwert von nur 64 zugewiesenen Ports hat. Hier wird nicht nur die Fähigkeit von DPA veranschaulicht, Portzuweisungen zu erhöhen, sondern auch, sie freizugeben, wenn sie nicht verwendet werden, damit sie von anderen Instanzen hinter demselben NAT-Gateway verwendet werden können.

9. Cloud NAT-Regeln mit DPA testen

Wir haben vor Kurzem auch die Funktion „NAT-Regeln“ für Cloud NAT eingeführt. Damit können Kunden Regeln schreiben, die bestimmte NAT-IP-Adressen für bestimmte externe Ziele verwenden. Weitere Informationen finden Sie auf der Dokumentationsseite zu NAT-Regeln.

In dieser Übung sehen wir uns die Interaktion zwischen DPA- und NAT-Regeln an. Definieren wir zuerst eine NAT-Regel für den Zugriff auf producer-address-2 über nat-address-2.

Führen Sie den folgenden gcloud-Befehl aus, um die NAT-Regel zu erstellen:

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 die folgende Ausgabe erhalten:

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

Führen wir get-nat-mapping-info noch einmal aus, 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

Beachten Sie, dass jetzt zusätzliche Ports (ebenfalls 64, das angegebene Minimum) speziell für nat-address-2 unter der ruleMappings-Hierarchie zugewiesen sind.

Was passiert also, wenn eine Instanz viele Verbindungen zum Ziel öffnet, das durch die NAT-Regel angegeben wird? Das lässt sich ganz einfach herausfinden.

Stellen Sie wieder eine SSH-Verbindung zur Instanz her:

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

Exportieren Sie die Umgebungsvariablen für die Producer-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"`

Führen wir nun die curl-Schleife noch einmal aus, diesmal für producerip2.

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 spiegeln sie den vorherigen Test wider. Beenden wir die SSH-Sitzung der Instanz und sehen wir uns die NAT-Zuweisungen noch einmal 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 oben zu sehen ist, hat die Standard-NAT-IP-Adresse von consumer-instance-1 ( die IP-Adresse für nat-address-1) weiterhin nur 64 zugewiesene Ports, die IP-Adresse der NAT-Regel (IP-Adresse für nat-address-2) hat jedoch 1.024 zugewiesene Ports. Dabei behielt consumer-instance-2 die Standardzuweisungen von 64 Ports für alle NAT-IPs bei.

Als Übung können Sie den umgekehrten Fall testen. Lassen Sie Cloud NAT alle zusätzlichen Ports freigeben und führen Sie dann die curl-Schleife für producerip1 aus. Beobachten Sie die Auswirkungen auf die Ausgabe von get-nat-mapping-info.

10. Bereinigungsschritte

Um wiederkehrende Gebühren zu vermeiden, sollten Sie alle Ressourcen löschen, die mit diesem Codelab verknüpft sind.

Löschen Sie zuerst alle Instanzen.

Über 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. Über Cloud Shell:

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

Sie sollten die folgende Ausgabe erhalten :

Deleted [https://www.googleapis.com/compute/v1/projects/<Project ID>/regions/us-east4/routers/consumer-cr].

Geben Sie alle externen IP-Adressen frei. Über Cloud Shell:

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

Sie sollten die folgende Ausgabe erhalten :

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

VPC-Firewallregeln löschen Über Cloud Shell:

gcloud compute firewall-rules delete consumer-allow-iap \
 producer-allow-80 --quiet

Sie sollten die folgende Ausgabe erhalten :

Deleted [https://www.googleapis.com/compute/v1/projects/<Project ID>/global/firewalls/consumer-allow-iap].
Deleted [https://www.googleapis.com/compute/v1/projects/<Project ID>/global/firewalls/producer-allow-80].

Subnetze löschen Über Cloud Shell:

gcloud compute networks subnets delete cons-net-e4 \
 prod-net-e4 --region=us-east4 --quiet

Sie sollten die folgende Ausgabe erhalten :

Deleted [https://www.googleapis.com/compute/v1/projects/<Project ID>/regions/us-east4/subnetworks/cons-net-e4].
Deleted [https://www.googleapis.com/compute/v1/projects/<Project ID>/regions/us-east4/subnetworks/prod-net-e4].

Löschen Sie schließlich die VPCs. Über Cloud Shell:

gcloud compute networks delete consumer-vpc \
 producer-vpc --quiet

Sie sollten die folgende Ausgabe erhalten :

Deleted [https://www.googleapis.com/compute/v1/projects/<Project ID>/global/networks/consumer-vpc].
Deleted [https://www.googleapis.com/compute/v1/projects/<Project ID>/global/networks/producer-vpc].

11. Glückwunsch!

Sie haben das Lab „Cloud NAT – DPA“ abgeschlossen.

Behandelte Themen

  • Ein Cloud NAT-Gateway zur Vorbereitung auf DPA einrichten
  • Portzuweisungen ohne DPA prüfen
  • So aktivieren und konfigurieren Sie DPA für ein NAT-Gateway.
  • Auswirkungen der Datenverarbeitungsvereinbarung durch parallele Ausgänge beobachten
  • So fügen Sie einem NAT-Gateway mit aktivierter DPA NAT-Regeln hinzu.
  • So sehen Sie das Verhalten von DPA mit Regeln, indem Sie ausgehende Verbindungen zu mehreren Zielen herstellen.

Nächste Schritte

© Google LLC oder deren Tochtergesellschaften. Alle Rechte vorbehalten. Nicht weitergeben.