Creazione di connessioni VPN ad alta disponibilità tra Google Cloud e AWS

Questo tutorial mostra come creare connessioni VPN ad alta disponibilità tra Google Cloud e Amazon Web Services (AWS) per la comunicazione diretta tra le reti VPC sulle due piattaforme cloud.

Questo tutorial presuppone la conoscenza dei concetti di base delle reti VPC (Virtual cloud privato), BGP (Border Gateway Protocol), reti private virtuali (VPN) e tunnel IPsec.

Google Cloud fornisce un servizio VPN ad alta disponibilità per connettere la tua rete VPC ad ambienti in esecuzione al di fuori di Google Cloud, ad esempio on-premise o su AWS tramite una connessione VPN IPsec. La VPN ad alta disponibilità offre uno SLA (accordo sul livello del servizio) con una disponibilità del servizio del 99,99% se configurata in base alle best practice di Google.

Panoramica dell'architettura

L'architettura descritta in questo documento include i seguenti componenti:

Router Cloud: un servizio Google Cloud completamente distribuito e gestito per fornire il routing dinamico tramite BGP per le tue reti VPC.
Gateway VPN ad alta disponibilità: un gateway VPN gestito da Google in esecuzione su Google Cloud. Ogni gateway VPN ad alta disponibilità è una risorsa di regione con due interfacce, ciascuna con i propri indirizzi IP esterni: l'interfaccia 0 e 1.
Tunnel VPN: connessioni dal gateway VPN ad alta disponibilità al gateway VPN peer su AWS attraverso il quale passa il traffico criptato.
Gateway VPN peer: due endpoint VPN Site-to-Site AWS, che possono provenire da un gateway privato virtuale AWS o un gateway di transito AWS.

Ognuna delle connessioni gateway VPN peer include due tunnel preconfigurati per puntare a un singolo gateway del cliente, che in questo caso è un'interfaccia VPN ad alta disponibilità di Google Cloud. Con questa configurazione, il numero minimo di tunnel per soddisfare lo SLA (accordo sul livello del servizio) con disponibilità del servizio del 99,99% è quattro.

Le opzioni di routing e la larghezza di banda combinata sui tunnel VPN variano in base all'opzione VPN Site-to-Site utilizzata su AWS:

Gateway per il trasporto pubblico: se crei il gateway di transito AWS senza preferenza BGP, la piattaforma ECMP distribuisce equamente il traffico tra i tunnel attivi.

Per utilizzare la connettività VPN su più reti Google Virtual Private Cloud, consulta le best practice per la creazione di un sistema hub e spoke in Google Cloud.

Per ulteriori informazioni sui gateway di transito AWS, consulta la documentazione di Amazon Virtual Private Cloud.
Gateway privato virtuale: se utilizzi un gateway privato virtuale AWS, viene selezionato un solo tunnel tra tutte le connessioni sul gateway. Per utilizzare più di un tunnel, utilizza invece un gateway di transito AWS in modo che sia disponibile ECMP.

Per i dettagli sulla priorità delle route VPN con AWS, consulta la documentazione sulle opzioni di routing VPN Site-to-Site AWS.

Per ulteriori informazioni sui gateway privati virtuali AWS, consulta la documentazione relativa ai tunnel VPN Site-to-Site AWS.

Il seguente diagramma mostra l'architettura.

Panoramica dell'architettura.

Obiettivi

Crea una rete VPC su Google Cloud.
Creare un gateway VPN ad alta disponibilità e un router Cloud su Google Cloud.
Creare i gateway dei clienti su AWS.
Crea una connessione VPN con routing dinamico su AWS.
Crea un gateway VPN esterno e tunnel VPN su Google Cloud.
Verificare e testare la connessione VPN tra le reti VPC su Google Cloud e AWS.

Modulo Terraform di esempio

Puoi utilizzare il modulo gcp-to-aws-ha-vpn-terraform-module per eseguire il provisioning della VPN ad alta disponibilità tra Google Cloud e AWS.

Costi

Questo tutorial utilizza i componenti fatturabili di Google Cloud, tra cui:

Per una stima dei costi per i componenti di Google Cloud, utilizza il Calcolatore prezzi di Google Cloud.

Questo tutorial utilizza i componenti fatturabili di Amazon Web Services, tra cui:

Gateway di transito AWS
VPN Site-to-Site AWS

Per una stima dei costi per i componenti AWS, utilizza il Calcolatore prezzi di AWS.

Prima di iniziare

Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

Nota: se non prevedi di conservare le risorse create in questa procedura, crea un progetto anziché selezionarne uno esistente. Dopo aver completato questi passaggi, puoi eliminare il progetto, rimuovendo tutte le risorse associate.

Vai al selettore progetti

Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

Attiva l'API Compute Engine.
Abilita l'API

Nella console Google Cloud, attiva Cloud Shell.

Attiva Cloud Shell
Assicurati di disporre dei ruoli amministrativi richiesti per configurare i componenti di networking:
- Amministratore di rete: compute.networkAdmin
- Amministratore sicurezza: compute.securityAdmin
- Amministratore Compute: compute.admin
Per maggiori informazioni sugli scopi di questi ruoli, consulta Ruoli IAM per mansioni correlate al networking.

Crea il gateway VPN ad alta disponibilità e il router Cloud su Google Cloud

In questa sezione creerai una rete VPC, un gateway VPN ad alta disponibilità e un router Cloud su Google Cloud.

In Cloud Shell, assicurati di lavorare nel progetto Google Cloud che hai creato o selezionato:
```
gcloud config set project YOUR_PROJECT_ID

export PROJECT_ID=`gcloud config list --format="value(core.project)"`
```
Sostituisci YOUR_PROJECT_ID con l'ID del tuo progetto Google Cloud.
Crea una rete VPC personalizzata con una singola subnet:
```
gcloud compute networks create NETWORK \
    --subnet-mode SUBNET_MODE \
    --bgp-routing-mode BGP_ROUTING_MODE
```
Sostituisci quanto segue:
- NETWORK: il nome della rete
- SUBNET_MODE: la modalità subnet
- BGP_ROUTING_MODE: la modalità di routing BGP
Il comando dovrebbe essere simile al seguente esempio:
```
gcloud compute networks create gc-vpc \
    --subnet-mode custom \
    --bgp-routing-mode global
```

Crea una subnet per ospitare le VM di test:

gcloud compute networks subnets create SUBNET_NAME \
    --network NETWORK \
    --region SUBNET_REGION \
    --range IP_ADDRESS_RANGE

Sostituisci quanto segue:

SUBNET_NAME: il nome della subnet
SUBNET_REGION: la regione in cui creare la subnet
IP_ADDRESS_RANGE: l'intervallo di indirizzi IP per la subnet

I comandi dovrebbero essere simili al seguente esempio:

gcloud compute networks subnets create subnet-east4  \
    --network gc-vpc \
    --region us-east4 \
    --range 10.1.1.0/24

Crea il gateway VPN ad alta disponibilità:
```
gcloud compute vpn-gateways create HA_VPN_GATEWAY_NAME \
    --network NETWORK \
    --region REGION
```
Sostituisci HA_VPN_GATEWAY_NAME con il nome del gateway VPN ad alta disponibilità.
Crea un router Cloud:
```
gcloud compute routers create ROUTER_NAME \
    --region REGION \
    --network NETWORK \
    --asn GOOGLE_ASN \
    --advertisement-mode custom \
    --set-advertisement-groups all_subnets
```
Sostituisci quanto segue:
- ROUTER_NAME: il nome del tuo router Cloud
- GOOGLE_ASN: l'ASN privato (numero di sistema autonomo) del router Cloud che stai creando. Può essere qualsiasi ASN privato nell'intervallo 64512-65534 o 4200000000-4294967294 che non stai già utilizzando come ASN peer nella stessa regione e nella stessa rete.
Il comando dovrebbe essere simile al seguente esempio:
```
gcloud compute routers create cloud-router \
    --region us-east4 \
    --network gc-vpc \
    --asn 65534 \
    --advertisement-mode custom \
    --set-advertisement-groups all_subnets
```

Questa procedura crea un gateway VPN con due interfacce. Prendi nota degli indirizzi esterni in modo da poterli utilizzare durante la configurazione del tuo ambiente sul lato AWS.

Crea gateway e connessioni VPN su AWS

In questa sezione creerai gateway dei clienti, un gateway di destinazione e connessioni VPN con routing dinamico.

Puoi eseguire i comandi AWS utilizzando l'interfaccia a riga di comando AWS.

Crea due gateway del cliente utilizzando il seguente comando AWS:

aws ec2 create-customer-gateway --type ipsec.1 --public-ip INTERFACE_0_IP_ADDRESS --bgp-asn GOOGLE_ASN

aws ec2 create-customer-gateway --type ipsec.1 --public-ip INTERFACE_1_IP_ADDRESS --bgp-asn GOOGLE_ASN

Sostituisci INTERFACE_0_IP_ADDRESS e INTERFACE_1_IP_ADDRESS con gli indirizzi IP pubblici dell'ultimo passaggio della sezione precedente.

Crea un gateway di destinazione e collegalo alla rete VPC.

Il gateway di destinazione può essere un gateway privato virtuale o un gateway di transito. Per maggiori informazioni, consulta Creare un gateway di destinazione.

Segui le istruzioni per un gateway privato virtuale o un gateway di trasporto pubblico:
- Gateway privato virtuale:
  1. Crea un gateway privato virtuale con un ASN AWS-side specifico:
```
aws ec2 create-vpn-gateway --type ipsec.1 --amazon-side-asn AWS_SIDE_ASN
```
    Sostituisci AWS_SIDE_ASN con l'ASN per il lato AWS.
    
    Questo comando dovrebbe essere simile al seguente esempio:
```
aws ec2 create-vpn-gateway --type ipsec.1 --amazon-side-asn 65001
```
  2. Collega il gateway privato virtuale alla rete VPC:
```
aws ec2 attach-vpn-gateway --vpn-gateway-id VPN_GATEWAY_ID --vpc-id VPC_ID
```
- Gateway per il trasporto pubblico:
  1. Crea un gateway di trasporto pubblico:
```
aws ec2 create-transit-gateway --description TRANSIT_GATEWAY_DESCRIPTION \
    --options=AmazonSideAsn=65001,AutoAcceptSharedAttachments=enable,DefaultRouteTableAssociation=enable,DefaultRouteTablePropagation=enable,VpnEcmpSupport=enable,DnsSupport=enable
```
    Sostituisci TRANSIT_GATEWAY_DESCRIPTION con una descrizione per il gateway di trasporto pubblico.
  2. Collega la tua rete VPC al gateway di transito:
```
aws ec2 create-transit-gateway-vpc-attachment \
    --transit-gateway-id TRANSIT_GATEWAY_ID \
    --vpc-id VPC_ID \
    --subnet-id SUBNET_ID
```
Crea una connessione VPN con routing dinamico.

Il metodo per creare una connessione VPN con routing dinamico varia a seconda che il gateway di destinazione sia un gateway privato virtuale o un gateway di transito. Per maggiori informazioni, consulta Creare una connessione VPN Site-to-Site.

Segui le istruzioni per un gateway privato virtuale o un gateway di trasporto pubblico:
- Gateway privato virtuale:
  
  Crea una connessione VPN con routing dinamico tra il gateway privato virtuale e i gateway del cliente e applica i tag alla connessione VPN:
```
    aws ec2 create-vpn-connection \
        --type ipsec.1 \
        --customer-gateway-id CUSTOMER_GATEWAY_1 \
        --vpn-gateway-id VPN_GATEWAY_ID \
        --options TunnelOptions='[{TunnelInsideCidr=AWS_T1_IP,PreSharedKey=SHARED_SECRET_1},{TunnelInsideCidr=AWS_T2_IP,PreSharedKey=SHARED_SECRET_2}]'

    aws ec2 create-vpn-connection \
        --type ipsec.1 \
        --customer-gateway-id CUSTOMER_GATEWAY_2 \
        --vpn-gateway-id VPN_GATEWAY_ID \
        --options TunnelOptions='[{TunnelInsideCidr=AWS_T3_IP,PreSharedKey=SHARED_SECRET_3},{TunnelInsideCidr=AWS_T4_IP,PreSharedKey=SHARED_SECRET_4}]'
```
- Gateway per il trasporto pubblico:
  
  Crea una connessione VPN con routing dinamico tra il gateway di transito e i gateway del cliente:
```
aws ec2 create-vpn-connection \
    --type ipsec.1 \
    --customer-gateway-id CUSTOMER_GATEWAY_1 \
    --transit-gateway-id TRANSIT_GATEWAY_ID \
    --options TunnelOptions='[{TunnelInsideCidr=AWS_T1_IP,PreSharedKey=SHARED_SECRET_1},{TunnelInsideCidr=AWS_T2_IP,PreSharedKey=SHARED_SECRET_2}]'

aws ec2 create-vpn-connection \
    --type ipsec.1 \
    --customer-gateway-id CUSTOMER_GATEWAY_2 \
    --transit-gateway-id TRANSIT_GATEWAY_ID \
    --options TunnelOptions='[{TunnelInsideCidr=AWS_T3_IP,PreSharedKey=SHARED_SECRET_3},{TunnelInsideCidr=AWS_T4_IP,PreSharedKey=SHARED_SECRET_4}]'
```
  Sostituisci quanto segue:
  - CUSTOMER_GATEWAY_1: gateway Google Cloud VPN, interfaccia 0
  - CUSTOMER_GATEWAY_2: gateway Google Cloud VPN, interfaccia 1
  - AWS_T1_IP: indirizzo IP interno per il gateway privato virtuale per la connessione 1, tunnel 1
  - AWS_T2_IP: indirizzo IP interno del gateway privato virtuale per la connessione 1, tunnel 2
  - AWS_T3_IP: indirizzo IP interno per il gateway privato virtuale per la connessione 2, tunnel 1
  - AWS_T4_IP: indirizzo IP interno per il gateway privato virtuale per la connessione 2, tunnel 2
  - SHARED_SECRET_1: chiave precondivisa per la connessione 1, tunnel 1
  - SHARED_SECRET_2: chiave precondivisa per la connessione 1, tunnel 2
  - SHARED_SECRET_3: chiave precondivisa per la connessione 2, tunnel 1
  - SHARED_SECRET_4: chiave precondivisa per la connessione 2, tunnel 2
  AWS prenota alcuni intervalli CIDR, pertanto non puoi utilizzare i valori in questi intervalli come all'interno degli indirizzi IP (AWS_T1_IP, AWS_T2_IP, AWS_T3_IP, AWS_T4_IP). Per informazioni su quali CIDR bloccano AWS, consulta la pagina relativa al CIDR per IPv4 del tunnel.
  
  Questi comandi creano quattro tunnel verso Google Cloud.
Scarica i file di configurazione per le due connessioni VPN.

Nei passaggi successivi, utilizzerai i valori dei file di configurazione per creare e configurare risorse sul lato Google Cloud.

Crea tunnel VPN e interfacce del router Cloud su Google Cloud

In questa sezione, utilizzerai le informazioni delle connessioni VPN AWS create nella sezione precedente per creare e configurare i componenti su Google Cloud.

Quando configuri i tunnel VPN su AWS, utilizza il protocollo di crittografia IKEv2 e seleziona meno set di trasformazione sul lato AWS. Ad esempio, seleziona una combinazione di singoli algoritmi di crittografia di fase 1 e 2, algoritmi di integrità e numeri di gruppo Diffie-Hellman (DH). In caso contrario, la nuova chiave del tunnel Cloud VPN può non riuscire a causa delle grandi dimensioni del payload dell'associazione di sicurezza (SA) per i set predefiniti di AWS transform. Queste grandi dimensioni del payload possono causare la frammentazione IP dei pacchetti IKE sul lato AWS, cosa non supportata da Cloud VPN. Per maggiori informazioni, consulta Opzioni tunnel per la connessione VPN Site-to-Site.

In Cloud Shell, crea un gateway VPN esterno con quattro interfacce per gli indirizzi IP esterni AWS:
```
gcloud compute external-vpn-gateways create PEER_GATEWAY_NAME --interfaces \
  0=AWS_GW_IP_1,1=AWS_GW_IP_2,2=AWS_GW_IP_3,3=AWS_GW_IP_4
```
Sostituisci quanto segue:
- AWS_GW_IP_1: indirizzo IP esterno per il gateway privato virtuale per la connessione 1, tunnel 1
- AWS_GW_IP_2: indirizzo IP esterno per il gateway privato virtuale per la connessione 1, tunnel 2
- AWS_GW_IP_3: indirizzo IP esterno per il gateway privato virtuale per la connessione 2, tunnel 1
- AWS_GW_IP_4: indirizzo IP esterno per il gateway privato virtuale per la connessione 2, tunnel 2

Crea quattro tunnel VPN:

Tunnel 1:

gcloud compute vpn-tunnels create tunnel-1 \
    --peer-external-gateway PEER_GATEWAY_NAME \
    --peer-external-gateway-interface 0 \
    --region REGION \
    --ike-version IKE_VERSION \
    --shared-secret SHARED_SECRET_1 \
    --router ROUTER_NAME \
    --vpn-gateway HA_VPN_GATEWAY_NAME \
    --interface 0

Tunnel 2:

gcloud compute vpn-tunnels create tunnel-2 \
    --peer-external-gateway PEER_GATEWAY_NAME \
    --peer-external-gateway-interface 1 \
    --region REGION \
    --ike-version IKE_VERSION \
    --shared-secret SHARED_SECRET_2 \
    --router ROUTER_NAME \
    --vpn-gateway HA_VPN_GATEWAY_NAME \
    --interface 0

Tunnel 3:

gcloud compute vpn-tunnels create tunnel-3 \
    --peer-external-gateway PEER_GATEWAY_NAME \
    --peer-external-gateway-interface 2 \
    --region REGION \
    --ike-version IKE_VERSION \
    --shared-secret SHARED_SECRET_3 \
    --router ROUTER_NAME \
    --vpn-gateway HA_VPN_GATEWAY_NAME \
    --interface 1

Tunnel 4:

gcloud compute vpn-tunnels create tunnel-4 \
    --peer-external-gateway PEER_GATEWAY_NAME \
    --peer-external-gateway-interface 3 \
    --region REGION \
    --ike-version IKE_VERSION \
    --shared-secret SHARED_SECRET_4 \
    --router ROUTER_NAME \
    --vpn-gateway HA_VPN_GATEWAY_NAME \
    --interface 1

Creare quattro interfacce del router Cloud.

Nei comandi seguenti, sostituisci ogni segnaposto GOOGLE_BGP_IP_TUNNEL con l'indirizzo IP interno del tunnel sul lato Google Cloud. Puoi trovare i valori nei file di configurazione VPN AWS come indirizzo del gateway del cliente per ogni tunnel. Ciascuno di questi indirizzi deve essere compreso nell'intervallo CIDR /30 nell'intervallo di rete 169.254.0.0/16.

Interfaccia del router Cloud 1:

gcloud compute routers add-interface ROUTER_NAME \
    --interface-name int-1 \
    --vpn-tunnel tunnel-1 \
    --ip-address GOOGLE_BGP_IP_TUNNEL_1 \
    --mask-length 30 \
    --region REGION

Interfaccia del router Cloud 2:

gcloud compute routers add-interface ROUTER_NAME \
    --interface-name int-2 \
    --vpn-tunnel tunnel-2 \
    --ip-address GOOGLE_BGP_IP_TUNNEL_2 \
    --mask-length 30 \
    --region REGION

Interfaccia del router Cloud 3:

gcloud compute routers add-interface ROUTER_NAME \
    --interface-name int-3 \
    --vpn-tunnel tunnel-3 \
    --ip-address GOOGLE_BGP_IP_TUNNEL_3 \
    --mask-length 30 \
    --region REGION

Interfaccia del router Cloud 4:

gcloud compute routers add-interface ROUTER_NAME \
    --interface-name int-4 \
    --vpn-tunnel tunnel-4 \
    --ip-address GOOGLE_BGP_IP_TUNNEL_4 \
    --mask-length 30 \
    --region REGION

Aggiungi peer BGP.

Nei comandi seguenti, sostituisci PEER_ASN con l'ASN per il lato AWS della sessione BGP.

Connessione AWS 1, tunnel 1

gcloud compute routers add-bgp-peer ROUTER_NAME \
    --peer-name aws-conn1-tunn1 \
    --peer-asn PEER_ASN \
    --interface int-1 \
    --peer-ip-address AWS_T1_IP \
    --region REGION

Connessione AWS 1, tunnel 2

gcloud compute routers add-bgp-peer ROUTER_NAME \
    --peer-name aws-conn1-tunn2 \
    --peer-asn PEER_ASN \
    --interface int-2 \
    --peer-ip-address AWS_T2_IP \
    --region REGION

Connessione AWS 2, tunnel 1

gcloud compute routers add-bgp-peer ROUTER_NAME \
    --peer-name aws-conn2-tunn1 \
    --peer-asn PEER_ASN \
    --interface int-3 \
    --peer-ip-address AWS_T3_IP \
    --region REGION

Connessione AWS 2, tunnel 2

gcloud compute routers add-bgp-peer ROUTER_NAME \
    --peer-name aws-conn2-tunn2 \
    --peer-asn PEER_ASN \
    --interface int-4 \
    --peer-ip-address AWS_T4_IP \
    --region REGION

Verificare la configurazione

In Cloud Shell, verifica lo stato del router Cloud:

gcloud compute routers get-status ROUTER_NAME \
    --region REGION \
    --format='flattened(result.bgpPeerStatus[].name, result.bgpPeerStatus[].ipAddress, result.bgpPeerStatus[].peerIpAddress)'

L'output è simile al seguente:

result.bgpPeerStatus[].peerIpAddress)'
result.bgpPeerStatus[0].ipAddress:     169.254.171.18
result.bgpPeerStatus[0].name:          aws-conn1-tunn1
result.bgpPeerStatus[0].peerIpAddress: 169.254.171.17
result.bgpPeerStatus[1].ipAddress:     169.254.156.154
result.bgpPeerStatus[1].name:          aws-conn1-tunn2
result.bgpPeerStatus[1].peerIpAddress: 169.254.156.153
result.bgpPeerStatus[2].ipAddress:     169.254.123.38
result.bgpPeerStatus[2].name:          aws-conn2-tunn1
result.bgpPeerStatus[2].peerIpAddress: 169.254.123.37
result.bgpPeerStatus[3].ipAddress:     169.254.48.186
result.bgpPeerStatus[3].name:          aws-conn2-tunn2
result.bgpPeerStatus[3].peerIpAddress: 169.254.48.185

Elenca tutti i tunnel:

gcloud compute vpn-tunnels list

L'output è simile al seguente:

NAME      REGION    GATEWAY    PEER_ADDRESS
tunnel-1  us-east4  ha-vpn-gw  34.205.x.x
tunnel-2  us-east4  ha-vpn-gw  52.203.x.x
tunnel-3  us-east4  ha-vpn-gw  3.208.x.x
tunnel-4  us-east4  ha-vpn-gw  52.204.x.x

Controlla lo stato del tunnel:

gcloud compute vpn-tunnels describe tunnel-1 \
     --region REGION \
     --format='flattened(status,detailedStatus)'

L'output è simile al seguente:

detailed_status: Tunnel is up and running.
status:          ESTABLISHED

Elenca le route dinamiche apprese dal router Cloud:

gcloud compute routers get-status ROUTER_NAME \
    --region REGION \
    --format="flattened(result.bestRoutes)"

L'output è simile al seguente:

result.bestRoutes[0].creationTimestamp: 2021-01-19T20:42:07.366-08:00
result.bestRoutes[0].destRange:         10.2.2.0/24
result.bestRoutes[0].kind:              compute#route
result.bestRoutes[0].nextHopIp:         169.254.171.17
result.bestRoutes[0].priority:          100
result.bestRoutes[1].creationTimestamp: 2021-01-19T20:42:07.366-08:00
result.bestRoutes[1].destRange:         10.2.2.0/24
result.bestRoutes[1].kind:              compute#route
result.bestRoutes[1].nextHopIp:         169.254.156.153
result.bestRoutes[1].priority:          100
result.bestRoutes[2].creationTimestamp: 2021-01-19T20:56:26.588-08:00
result.bestRoutes[2].destRange:         10.2.2.0/24
result.bestRoutes[2].kind:              compute#route
result.bestRoutes[2].nextHopIp:         169.254.123.37
result.bestRoutes[2].priority:          100
result.bestRoutes[3].creationTimestamp: 2021-01-19T20:56:26.588-08:00
result.bestRoutes[3].destRange:         10.2.2.0/24
result.bestRoutes[3].kind:              compute#route
result.bestRoutes[3].nextHopIp:         169.254.48.185
result.bestRoutes[3].priority:          100

Verifica la connettività

Crea VM di test su ciascun lato dei tunnel per testare le richieste di ping.

Assicurati di disporre di regole firewall per consentire il traffico ICMP.
- Per istruzioni su come creare VM in Compute Engine, consulta la Guida introduttiva.
- Per istruzioni sulla creazione di VM su AWS, consulta Avviare una macchina virtuale.
Testa la connessione utilizzando il comando ping.
Misura la larghezza di banda tra le tue macchine di test utilizzando iperf.
- Lato server:
```
iperf3 -s
```
- Lato client:
```
iperf3 -c SERVER_IP_ADDRESS -P NUMBER_OF_PARALLEL_SESSIONS
```

Esegui la pulizia

Elimina le risorse Google Cloud e AWS che hai creato durante questo tutorial.

Elimina il progetto Google Cloud

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, puoi eliminare il tuo progetto:

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività in questo documento, quando lo elimini elimini anche qualsiasi altro lavoro svolto nel progetto.
Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, puoi riutilizzare i progetti ed evitare così di superare i limiti di quota.

Nella console Google Cloud, vai alla pagina Gestisci risorse.
Vai a Gestisci risorse
Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Elimina risorse AWS

Passaggi successivi

Scopri di più sulla VPN Google Cloud.
Scopri di più su best practice e architetture di riferimento per la progettazione di VPC.