Utilizzo delle regole Cloud NAT

1. Panoramica

Cloud NAT è uno strumento potente che consente ai carichi di lavoro di Compute Engine e Google Kubernetes Engine (GKE) di accedere alle risorse internet in modo scalabile e sicuro, senza esporre i carichi di lavoro in esecuzione su di essi all'accesso esterno tramite IP esterni.

Cloud NAT è caratterizzato da un design senza proxy che implementa NAT direttamente nel livello SDN di Andromeda. Di conseguenza, non c'è alcun impatto sulle prestazioni del carico di lavoro e consente la scalabilità senza sforzo per molte VM, regioni e VPC.

Le regole NAT sono un'estensione di Cloud NAT. La funzionalità Regole NAT in Cloud NAT consente di creare regole di accesso che definiscono la modalità di utilizzo di Cloud NAT per la connessione a internet. Attualmente le regole NAT supportano la selezione degli indirizzi NAT di origine in base all'indirizzo di destinazione.

In assenza di regole NAT, una VM con Cloud NAT abilitato utilizza lo stesso set di indirizzi IP NAT per raggiungere tutti gli indirizzi internet.

A volte, un caso d'uso NAT richiede a Cloud NAT di utilizzare indirizzi IP di origine diversi per destinazioni specifiche. Una regola NAT definisce una corrispondenza e un'azione corrispondente. Una volta specificate le regole NAT, il pacchetto corrisponde a ciascuna regola NAT. Se viene rilevata una corrispondenza a una regola, viene eseguita l'azione corrispondente.

Per ulteriori informazioni, consulta la sezione della documentazione sulle regole NAT .

Cosa imparerai a fare

• Come configurare un gateway Cloud NAT in preparazione per le regole NAT.
• Come progettare regole NAT utilizzando CEL (Common Expression Language).
• Come creare regole NAT e collegarle a un gateway NAT.
• Come testare le regole NAT da un'istanza.
• Come aggiornare le regole di un gateway NAT.
• Come eliminare le regole NAT e ripristinare il comportamento predefinito di Cloud NAT.

Che cosa ti serve

• Conoscenza di base di Google Compute Engine
• Conoscenza di base del networking e di TCP/IP
• Conoscenza di base della riga di comando Unix/Linux
• È utile aver completato un tour del networking in Google Cloud, come il lab Networking in Google Cloud.
• Comprensione delle nozioni di base di Cloud NAT.

2. Utilizzo della console Google Cloud e di Cloud Shell

Per interagire con Google Cloud, utilizzeremo sia la console Google Cloud sia Cloud Shell durante questo lab.

Google Cloud Console

La console Cloud è disponibile all'indirizzo https://console.cloud.google.com.

Configurazione dell'ambiente da seguire in modo autonomo

1. Accedi alla console Cloud e crea un nuovo progetto o riutilizzane uno esistente. Se non hai ancora un account Gmail o Google Workspace, devi crearne uno.

Nota: puoi accedere facilmente alla console Cloud memorizzando il relativo URL, che è console.cloud.google.com.

• Il Nome progetto è il tuo identificatore personale per questo progetto. Se segui le convenzioni di denominazione, puoi utilizzare tutto ciò che desideri e aggiornarlo in qualsiasi momento.
• L'ID progetto deve essere univoco in tutti i progetti Google Cloud ed è immutabile (non può essere modificato una volta impostato). La console Cloud genera automaticamente una stringa univoca. di solito non ti importa cosa sia. Nella maggior parte dei codelab, devi fare riferimento all'ID progetto (che solitamente è identificato come PROJECT_ID), quindi, se non ti piace, generane un altro a caso oppure puoi fare un tentativo personalizzato e controllare se è disponibile. Poi c'è "congelato" una volta creato il progetto.

Attenzione:un ID progetto deve essere univoco a livello globale e, una volta selezionato, non può essere utilizzato da nessun altro. Sarai l'unico utente di quell'ID. Se un progetto viene eliminato, quell'ID non può più essere riutilizzato.

Nota:se utilizzi un account Gmail, puoi lasciare la posizione predefinita impostata su Nessuna organizzazione. Se utilizzi un account Google Workspace, scegli una località adatta alla tua organizzazione.

2. Successivamente, dovrai abilitare la fatturazione in Cloud Console per utilizzare le risorse Google Cloud.

Eseguire questo codelab non dovrebbe costare molto. Assicurati di seguire le istruzioni nella sezione "Pulizia" in cui viene spiegato come arrestare le risorse in modo da non incorrere in fatturazione oltre questo tutorial. I nuovi utenti di Google Cloud sono idonei al programma prova senza costi di 300$.

Avvia Cloud Shell

Anche se Google Cloud può essere utilizzato da remoto dal tuo laptop, in questo codelab utilizzerai Google Cloud Shell, un ambiente a riga di comando in esecuzione nel cloud.

Dalla console di Google Cloud, fai clic sull'icona di Cloud Shell nella barra degli strumenti in alto a destra:

Dovrebbe richiedere solo qualche istante per eseguire il provisioning e connettersi all'ambiente. Al termine, dovresti vedere una schermata simile al seguente:

Questa macchina virtuale viene caricata con tutti gli strumenti di sviluppo necessari. Offre una home directory permanente da 5 GB e viene eseguita su Google Cloud, migliorando notevolmente le prestazioni di rete e l'autenticazione. Tutto il lavoro in questo lab può essere svolto semplicemente con un browser.

3. Configurazione del lab

Per questo lab, utilizzerai un progetto e creerai due VPC con una subnet ciascuno. Prenoterai indirizzi IP esterni e quindi creerai e configurerai un gateway Cloud NAT (con un router Cloud), due istanze producer e un'istanza consumer. Dopo aver convalidato il comportamento predefinito di Cloud NAT, creerai regole Cloud NAT personalizzate e convaliderai il relativo comportamento.

Nota: utilizzeremo i comandi Cloud Shell e gcloud per configurare questo lab.

Panoramica dell'architettura di networking:

4. Prenota indirizzi IP esterni

Prenotiamo tutti gli indirizzi IP esterni da utilizzare in questo lab. Questo ti aiuterà a scrivere tutte le regole NAT e firewall pertinenti nel VPC consumer e producer.

Da Cloud Shell:

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

Output:

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/nat-address-3].
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].

Compila gli indirizzi IP riservati come variabili di ambiente.

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 natip3=`gcloud compute addresses list --filter name:nat-address-3 --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)"`

Non è previsto alcun output, ma è necessario verificare che gli indirizzi siano stati compilati correttamente. Inviamo un output con i valori di tutte le variabili di ambiente.

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

Output:

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

5. VPC del producer e configurazione delle istanze.

Ora creeremo le risorse per le risorse producer. Le istanze in esecuzione nel VPC del producer offriranno il servizio per internet utilizzando due IP pubblici "producer-address-1" e "producer-address-2" di Google.

Innanzitutto, creiamo il VPC. Da Cloud Shell:

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

Output:

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

Ora creiamo la subnet in us-east4. Da Cloud Shell:

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

Output:

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

Ora creiamo le regole firewall VPC per consentire agli indirizzi IP NAT di raggiungere le istanze del producer sulla porta 8080.

Per la prima regola, da Cloud Shell:

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

Output:

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

Il passaggio successivo prevede la creazione delle due istanze producer.

Le istanze del producer eseguiranno un servizio di echo IP in un container Docker disponibile su Docker Hub (il codice sorgente è disponibile nel repository GitHub dell'autore del servizio).

Per eseguire rapidamente il provisioning delle istanze con tutto il software richiesto, utilizzeremo la funzionalità Deployment di container su Compute Engine.

Per poter scrivere regole NAT, eseguiremo il provisioning di ogni istanza con un indirizzo IP riservato diverso.

Crea la prima istanza. Da Cloud Shell:

gcloud compute instances create-with-container producer-instance-1 \
--zone=us-east4-a --machine-type=e2-medium \
--network-interface=address=producer-address-1,network-tier=PREMIUM,subnet=producer-e4 \
--container-image=mpolden/echoip --container-restart-policy=always

Output:

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 IP 1>  RUNNING

Poi crea la seconda istanza. Da Cloud Shell:

gcloud compute instances create-with-container producer-instance-2 \
 --zone=us-east4-a --machine-type=e2-medium \
--network-interface=address=producer-address-2,network-tier=PREMIUM,subnet=producer-e4 \
--container-image=mpolden/echoip --container-restart-policy=always

Output:

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 IP 2>  RUNNING

6. Configura VPC consumer, Cloud NAT e istanza

Ora che hai creato il servizio producer, è il momento di creare il VPC consumer e il relativo gateway Cloud NAT.

Dopo aver creato il VPC e la subnet, aggiungeremo una semplice regola firewall in entrata per consentire gli intervalli IP di origine IAP per TCP. Questo ci consentirà di stabilire una connessione SSH direttamente alle istanze consumer utilizzando gcloud.

Creeremo quindi un semplice gateway Cloud NAT in modalità di allocazione manuale e l'indirizzo riservato "nat-address-1" associate. Nelle parti successive del codelab, aggiorneremo la configurazione del gateway per aggiungere regole personalizzate. .

Innanzitutto, creiamo il VPC. Da Cloud Shell:

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

Output:

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 producer-vpc --allow tcp:22,tcp:3389,icmp

Ora creiamo una subnet in us-east4. Da Cloud Shell:

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

Output:

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

Ora creiamo una regola firewall VPC per consentire agli indirizzi degli intervalli IAP di raggiungere le istanze consumer sulla porta 22.

Per la prima regola firewall, esegui il comando seguente da Cloud Shell:

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

Output:

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

Prima di creare un gateway NAT, dobbiamo creare un'istanza di router Cloud (utilizziamo un numero ASN privato, ma non è pertinente per le attività di questo lab). Da Cloud Shell:

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

Output:

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

Quindi crea l'istanza del gateway NAT. Da 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

Output:

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

Crea l'istanza di test consumer. Popoliamo qui gli IP dei producer prenotati per poterli consultare in un secondo momento all'interno dell'istanza. Da Cloud Shell:

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

Output:

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

7. Verifica il comportamento predefinito di Cloud NAT

A questo punto, l'istanza consumer utilizza il comportamento Cloud NAT predefinito che usa lo stesso IP riservato "nat-address-1" per comunicare con tutti gli indirizzi esterni.

Convalidiamo questo comportamento prima di utilizzare la nuova funzionalità delle regole NAT in Cloud NAT.

Accedi tramite SSH all'istanza consumer. Da Cloud Shell:

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

A questo punto dovresti essere nella shell dell'istanza.

Output di esempio (output completo troncato per brevità)

No zone specified. Using zone [us-east4-a] for instance: [consumer-instance].
External IP address was not found; defaulting to using IAP tunneling.
...
...
<username>@consumer-instance:~$

Dall'interno dell'istanza consumer, innanzitutto recuperiamo gli IP dei producer e li completiamo come variabili di ambiente

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

Quindi, prova a eseguire il comando curl verso entrambe le istanze del producer e osserva l'indirizzo IP di origine restituito.

<username>@consumer-instance:~$ curl http://$producerip1:8080
34.136.8.83
<username>@consumer-instance:~$ curl http://$producerip2:8080
34.136.8.83

Dovresti vedere lo stesso indirizzo IP restituito per entrambi gli endpoint, che è uguale al valore dell'IP riservato esterno "nat-address-1".

Allo stesso modo, un comando curl a qualsiasi servizio di riflettore IP esterno dovrebbe mostrare lo stesso IP, ad esempio:

<username>@consumer-instance:~$ curl http://ifconfig.co
34.136.8.83
<username>@consumer-instance:~$ curl http://ifconfig.me
34.136.8.83
<username>@consumer-instance:~$ curl http://ip.fyr.io
34.136.8.83

Esci dalla sessione SSH dell'istanza per ora, torneremo tramite SSH dopo aver configurato le regole NAT.

8. Crea regole Cloud NAT

Le regole NAT sono scritte utilizzando la sintassi Common Expression Language. Per saperne di più sul linguaggio delle espressioni delle regole, consulta la sezione Linguaggio delle espressioni di regole.

Puoi aggiungere una regola NAT a un gateway NAT esistente anche utilizzando i comandi gcloud. Esploreremo entrambe le opzioni per creare regole Cloud NAT.

Per prima cosa creiamo un file YAML della regola NAT.

Da Cloud Shell:

export projectid=`gcloud config get-value project`

cat <<EOF >natrulesfile.txt
rules:
 - ruleNumber: 100
   match: destination.ip == '$producerip2'
   action:
     sourceNatActiveIps:
     -  /projects/$projectid/regions/us-east4/addresses/nat-address-2
EOF

Quindi aggiorniamo il gateway NAT esistente utilizzando questo file delle regole. Da Cloud Shell:

gcloud alpha compute routers nats update consumer-nat-gw \
    --router=consumer-cr \
    --rules=natrulesfile.txt \
    --router-region=us-east4

Dovresti vedere l'output seguente :

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

Verifica che la regola sia stata configurata correttamente. Da Cloud Shell:

gcloud alpha compute routers nats rules list \
--nat=consumer-nat-gw --router=consumer-cr \
--router-region=us-east4

Dovresti vedere l'output seguente :

RULE_NUMBER  MATCH
100          destination.ip == '35.192.142.134'

Proviamo a ricreare la stessa regola utilizzando solo i comandi gcloud. Elimina prima la regola esistente. Da Cloud Shell:

gcloud alpha compute routers nats rules delete 100 \
--nat=consumer-nat-gw --router=consumer-cr \
--router-region=us-east4 --quiet

Dovresti vedere l'output seguente :

Updated [https://www.googleapis.com/compute/alpha/projects/ghaleb-s2/regions/us-east4/routers/consumer-cr]

Quindi ricrea la regola utilizzando questo comando gcloud. Da Cloud Shell:

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

Dovresti vedere l'output seguente :

Creating Rule [100] in NAT [consumer-nat-gw]...done.

Anche in questo caso per verificare che la regola sia stata creata correttamente, ripeti il comando precedente. Questa volta aggiungeremo l'opzione di formattazione YAML per vedere i dettagli completi della regola.

Da Cloud Shell:

gcloud alpha compute routers nats rules list\
 --nat=consumer-nat-gw --router=consumer-cr \
--router-region=us-east4  --format=yaml

Dovresti vedere l'output seguente :

---
action:
  sourceNatActiveIps:
  - https://www.googleapis.com/compute/alpha/projects/<Project-ID>/regions/us-east4/addresses/nat-address-2
match: destination.ip == <actual IP for producer-IP 2>
ruleNumber: 100

Infine, noterai che ora sia "nat-address1" e "nat-address-2" gli indirizzi esterni vengono visualizzati come "IN_USE". Per farlo, esegui questo comando da Cloud Shell:

$ gcloud compute addresses list

Dovrebbe essere visualizzato il seguente output (gli indirizzi IP effettivi devono corrispondere a quelli che hai prenotato) :

NAME                ADDRESS/RANGE   TYPE      PURPOSE  NETWORK  REGION       SUBNET  STATUS
nat-address-1       34.136.8.83     EXTERNAL                    us-east4          IN_USE
nat-address-2       34.70.137.35    EXTERNAL                    us-east4          IN_USE
nat-address-3       34.135.103.88   EXTERNAL                    us-east4          RESERVED
producer-address-1  34.66.0.105     EXTERNAL                    us-east4          IN_USE
producer-address-2  35.192.142.134  EXTERNAL                    us-east4          IN_USE

9. Verifica il comportamento delle regole Cloud NAT

A questo punto, l'istanza consumer deve usare la regola Cloud NAT creata per utilizzare nat-address-2 per comunicare con producer-address-2.

Convalidiamo questo comportamento. Accedi tramite SSH all'istanza consumer. Da Cloud Shell:

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

A questo punto dovresti essere nella shell dell'istanza.

Output di esempio (output completo troncato per brevità)

No zone specified. Using zone [us-east4-a] for instance: [consumer-instance].
External IP address was not found; defaulting to using IAP tunneling.
...
...
<username>@consumer-instance:~$

Dall'interno dell'istanza consumer, innanzitutto recuperiamo gli IP dei producer e li completiamo come variabili di ambiente

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

Quindi, prova a eseguire il comando curl verso entrambe le istanze del producer e osserva l'indirizzo IP di origine restituito.

<username>@consumer-instance:~$ curl http://$producerip1:8080
34.136.8.83
<username>@consumer-instance:~$ curl http://$producerip2:8080
34.70.137.35

Ora dovresti vedere che viene restituito un indirizzo IP diverso per entrambi gli endpoint: il primo indirizzo IP dovrebbe essere uguale al comportamento predefinito. Il secondo indirizzo IP deve essere uguale a "nat-address-2" dopo l'aggiunta della nuova regola NAT.

Un curl verso qualsiasi servizio di riflettore IP esterno dovrebbe comunque mostrare lo stesso IP del comportamento predefinito, ad esempio:

<username>@consumer-instance:~$ curl http://ifconfig.co
34.136.8.83
<username>@consumer-instance:~$ curl http://ifconfig.me
34.136.8.83
<username>@consumer-instance:~$ curl http://ip.fyr.io
34.136.8.83

Esci dalla sessione SSH dell'istanza per ora, torneremo tramite SSH per testare lo svuotamento degli indirizzi.

10. Aggiorna e Elimina regole Cloud NAT

Puoi aggiornare le regole Cloud NAT esistenti. Ad esempio, puoi associare nuovi indirizzi IP e svuotare gli indirizzi IP esistenti associati a regole esistenti.

Aggiorniamo il file delle regole NAT come segue

Da Cloud Shell:

export projectid=`gcloud config get-value project`

cat <<EOF >natrulesfile.txt
rules:
 - ruleNumber: 100
   match: destination.ip == '$producerip2'
   action:
     sourceNatDrainIps:
     -  /projects/$projectid/regions/us-east4/addresses/nat-address-2
     sourceNatActiveIps:
     -  /projects/$projectid/regions/us-east4/addresses/nat-address-3
EOF

La funzione di questo nuovo file è ora "nat-address-2" in uno stato svuotato. E aggiungi "nat-address-3" nello stato attivo. Ciò dovrebbe consentire la terminazione corretta delle connessioni esistenti che utilizzano nat-address-2 e la creazione di nuove connessioni utilizzando solo nat-address-3.

Quindi aggiorniamo il gateway NAT esistente utilizzando questo file delle regole. Da Cloud Shell:

gcloud alpha compute routers nats update consumer-nat-gw \
    --router=consumer-cr \
    --rules=natrulesfile.txt \
    --router-region=us-east4

Dovresti vedere l'output seguente :

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

Verifica che la regola sia stata configurata correttamente. Da Cloud Shell:

gcloud alpha compute routers nats rules list \
--nat=consumer-nat-gw --router=consumer-cr \
--router-region=us-east4 --format=yaml

Dovresti vedere l'output seguente :

---
action:
  sourceNatActiveIps:
  - https://www.googleapis.com/compute/alpha/projects/ghaleb-s2/regions/us-east4/addresses/nat-address-3
  sourceNatDrainIps:
  - https://www.googleapis.com/compute/alpha/projects/ghaleb-s2/regions/us-east4/addresses/nat-address-2
match: destination.ip == '35.192.142.134'
ruleNumber: 100

Come vedi, "nat-address-2" è stato sottoposto a svuotamento. Lasciamo a te un esercizio per verificare che le nuove connessioni dal VPC consumer ora utilizzino gli IP NAT corretti.

Infine, elimina le regole NAT dal gateway Cloud NAT e ripristina il comportamento predefinito. Puoi utilizzare il seguente comando gcloud. Da Cloud Shell:

gcloud alpha compute routers nats rules delete 100 \
 --nat=consumer-nat-gw --router=consumer-cr \
 --router-region=us-east4 --quiet

Dovresti vedere l'output seguente :

Updated [https://www.googleapis.com/compute/alpha/projects/ghaleb-s2/regions/us-east4/routers/consumer-cr]

Per verificare che non esistano altre regole NAT, utilizziamo il comando describe del gateway NAT

gcloud alpha compute routers nats describe consumer-nat-gw \
 --router=consumer-cr --router-region=us-east4

Dovresti vedere l'output seguente :

enableEndpointIndependentMapping: false
name: consumer-nat-gw
natIpAllocateOption: MANUAL_ONLY
natIps:
- https://www.googleapis.com/compute/alpha/projects/ghaleb-s2/regions/us-east4/addresses/nat-address-1
sourceSubnetworkIpRangesToNat: ALL_SUBNETWORKS_ALL_IP_RANGES

Come puoi notare, non esiste un "regole": nel file YAML di output. Indica l'assenza di regole NAT configurate.

11. Procedura di pulizia

Per evitare addebiti ricorrenti, devi eliminare tutte le risorse associate a questo codelab.

Elimina prima tutte le istanze.

Da Cloud Shell:

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

Output previsto :

Deleted [https://www.googleapis.com/compute/v1/projects/<Project Id>/zones/us-east4-a/instances/consumer-instance].
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].

Quindi, elimina il router Cloud. Da Cloud Shell:

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

Dovresti vedere l'output seguente :

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

Rilascia tutti gli indirizzi IP esterni. Da Cloud Shell:

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

Dovresti vedere l'output seguente :

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

Elimina le regole firewall VPC. Da Cloud Shell:

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

Dovresti vedere l'output seguente :

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-8080].

Elimina le subnet. Da Cloud Shell:

gcloud compute networks subnets delete consumer-e4 \
producer-e4 --region=us-east4 --quiet

Dovresti vedere l'output seguente :

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

Infine, eliminiamo i VPC. Da Cloud Shell:

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

Dovresti vedere l'output seguente :

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

12. Complimenti!

Hai completato il lab sulle regole di Cloud NAT.

Argomenti trattati

• Come configurare un gateway Cloud NAT in preparazione per le regole NAT.
• Come progettare regole NAT utilizzando CEL (Common Expression Language).
• Come creare regole NAT e collegarle a un gateway NAT.
• Come testare le regole NAT da un'istanza.
• Come aggiornare le regole di un gateway NAT.
• Come eliminare le regole NAT e ripristinare il comportamento predefinito di Cloud NAT.

Passaggi successivi

• Prova a creare regole NAT più complesse come questo esempio
• Esplora lo svuotamento degli indirizzi IP NAT e osserva l'impatto della connessione.
• Scopri di più sul networking su Google Cloud Platform

©Google, Inc. e/o le sue società consociate. Tutti i diritti riservati. Distribuzione vietata.