Usa Public NAT con GKE

Questa pagina mostra come configurare una configurazione Public NAT di esempio con Google Kubernetes Engine (GKE). Prima di configurare Public NAT, leggi le Panoramica di Public NAT.

Prerequisiti

Prima di configurare Public NAT, devi effettuare le seguenti operazioni.

Ottieni autorizzazioni IAM

Il ruolo roles/compute.networkAdmin ti concede le autorizzazioni per creare un gateway NAT sul router Cloud, prenotare e assegnare indirizzi IP NAT e specificare le subnet (subnet) per il traffico deve utilizzare la Network Address Translation da parte del gateway NAT.

Configurare Google Cloud

Prima di iniziare, configura i seguenti elementi in Google Cloud.

1. Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

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

4. Install the Google Cloud CLI.

5. To initialize the gcloud CLI, run the following command:

   gcloud init

6. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

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

8. Install the Google Cloud CLI.

9. To initialize the gcloud CLI, run the following command:

   gcloud init

Nota:

Le istruzioni per l'interfaccia a riga di comando di Google Cloud in questa pagina presuppongono che hai impostato il tuo ID progetto prima di inviare comandi. Puoi impostare un ID progetto con il seguente comando:

    gcloud config set project PROJECT_ID
  

Puoi anche visualizzare un ID progetto già impostato:

    gcloud config list --format='text(core.project)'
  

Esempio di configurazione di GKE

Utilizza questo esempio se vuoi visualizzare un semplice Public NAT di lavoro con GKE.

Passaggio 1: crea una rete VPC e una subnet

Se hai già una rete e una subnet, puoi saltare questo passaggio.

Console

1. Nella console Google Cloud, vai alla pagina Reti VPC.

   Vai alla pagina Reti VPC

2. Fai clic su Crea rete VPC.

3. Inserisci custom-network1 come nome.

4. In Subnet, imposta Modalità creazione subnet su Personalizzata.

5. In Nuova subnet, inserisci subnet-us-east-192 come Nome.

6. In Regione, seleziona us-east4.

7. Inserisci un intervallo di indirizzi IP pari a 192.168.1.0/24.

8. Fai clic su Fine, quindi su Crea.

gcloud

1. Crea una nuova rete Virtual Private Cloud (VPC) in modalità personalizzata nel tuo progetto:

   gcloud compute networks create custom-network1 \
       --subnet-mode custom

   Output:

   NAME             MODE     IPV4_RANGE   GATEWAY_IPV4
   custom-network1  custom

   Nota: poiché questa è una rete VPC, non sono intervallo IPv4 a livello di rete o indirizzo IP del gateway, quindi non viene visualizzato nessuno.

2. Specifica il prefisso della subnet per la tua prima regione. In questo esempio, assegna 192.168.1.0/24 alla regione us-east4.

   gcloud compute networks subnets create subnet-us-east-192 \
      --network custom-network1 \
      --region us-east4 \
      --range 192.168.1.0/24

   Output:

   NAME                REGION    NETWORK          RANGE
   subnet-us-east-192  us-east4  custom-network1  192.168.1.0/24

Terraform

Puoi utilizzare un modulo Terraform per creare una rete Virtual Private Cloud personalizzata. e una subnet.

module "test-vpc-module" {
  source       = "terraform-google-modules/network/google"
  version      = "~> 9.0"
  project_id   = var.project_id # Replace this with your project ID in quotes
  network_name = "custom-network1"
  mtu          = 1460

  subnets = [
    {
      subnet_name   = "subnet-us-east-192"
      subnet_ip     = "192.168.1.0/24"
      subnet_region = "us-east4"
    }
  ]
}

Passaggio 2: crea un cluster privato

Console

1. Nella console Google Cloud, vai alla pagina Cluster Kubernetes.

   Vai alla pagina dei cluster Kubernetes

2. Fai clic su Crea cluster.

3. In Nome, inserisci nat-test-cluster.

4. Imposta Tipo di località su A livello di zona.

5. Imposta Zone su us-east4-c.

6. Nel riquadro di navigazione, fai clic su Networking.

7. Seleziona Cluster privato.

8. Deseleziona la casella di controllo Accedi al piano di controllo utilizzando l'indirizzo IP esterno.

9. Inserisci un Intervallo IP del piano di controllo di 172.16.0.0/28.

10. Imposta Rete su custom-network1.

11. Per creare e avviare il cluster, fai clic su Crea.

gcloud

gcloud container clusters create "nat-test-cluster" \
    --zone "us-east4-c" \
    --username "admin" \
    --cluster-version "latest" \
    --machine-type "e2-medium" \
    --disk-type "pd-standard" \
    --disk-size "100" \
    --scopes "https://www.googleapis.com/auth/compute","https://www.googleapis.com/auth/devstorage.read_only","https://www.googleapis.com/auth/logging.write","https://www.googleapis.com/auth/monitoring","https://www.googleapis.com/auth/servicecontrol","https://www.googleapis.com/auth/service.management.readonly","https://www.googleapis.com/auth/trace.append" \
    --num-nodes "3" \
    --enable-private-nodes \
    --enable-private-endpoint \
    --master-ipv4-cidr "172.16.0.0/28" \
    --enable-ip-alias \
    --network "projects/PROJECT_ID/global/networks/custom-network1" \
    --subnetwork "projects/PROJECT_ID/regions/us-east4/subnetworks/subnet-us-east-192" \
    --max-nodes-per-pool "110" \
    --enable-master-authorized-networks \
    --addons HorizontalPodAutoscaling,HttpLoadBalancing \
    --enable-autoupgrade \
    --enable-autorepair

Terraform

Puoi utilizzare una risorsa Terraform per creare un cluster privato.

resource "google_container_cluster" "primary" {
  project            = var.project_id
  name               = "nat-test-cluster"
  location           = "us-east4-c"
  initial_node_count = 3
  network            = var.network # Replace with a reference or self link to your network, in quotes
  subnetwork         = var.subnet  # Replace with a reference or self link to your subnet, in quotes
  private_cluster_config {
    master_ipv4_cidr_block  = "172.16.0.0/28"
    enable_private_endpoint = true
    enable_private_nodes    = true
  }
  ip_allocation_policy {
  }
  master_authorized_networks_config {
  }
}

Passaggio 3: crea una regola firewall che consenta le connessioni SSH

Console

1. Nella console Google Cloud, vai alla pagina Criteri firewall.

   Vai alla pagina Criteri firewall

2. Fai clic su Crea regola firewall.

3. Inserisci allow-ssh come nome.

4. Specifica una rete di custom-network1.

5. Imposta la Direzione del traffico su In entrata.

6. Imposta Azione in caso di corrispondenza su Consenti.

7. Imposta Destinazioni su Tutte le istanze nella rete.

8. Imposta Filtro di origine su Intervalli IPv4.

9. Imposta Intervalli IP di origine su 35.235.240.0/20.

10. Imposta Protocolli e porte su Protocolli e porte specificati.

11. Seleziona la casella di controllo tcp e inserisci la porta 22.

12. Fai clic su Crea.

gcloud

gcloud compute firewall-rules create allow-ssh \
    --network custom-network1 \
    --source-ranges 35.235.240.0/20 \
    --allow tcp:22

Terraform

Puoi utilizzare una risorsa Terraform per creare una regola firewall.

resource "google_compute_firewall" "rules" {
  project = var.project_id
  name    = "allow-ssh"
  network = var.network
  allow {
    protocol = "tcp"
    ports    = ["22"]
  }
  source_ranges = ["35.235.240.0/20"]
}

Passaggio 4: crea le autorizzazioni SSH IAP per uno dei nodi

In un passaggio successivo, utilizza IAP per connetterti al nodo.

Console

1. Nella console Google Cloud, vai alla pagina Identity-Aware Proxy.

   Vai alla pagina Identity-Aware Proxy

2. Seleziona la scheda Risorse SSH e TCP.

3. Seleziona la casella di controllo accanto al primo nodo nell'elenco sotto Tutte le risorse tunnel > us-east4-c. Il suo nome sarà simile a gke-nat-test-cluster-default-pool-b50db58d-075t.

4. Annota il nome del nodo; in seguito, lo utilizzerai per testare e la connettività privata.

5. Nel riquadro a destra, fai clic su Aggiungi entità.

6. Per concedere a utenti, gruppi o account di servizio l'accesso alle risorse, Nel campo Nuove entità, specifica i relativi indirizzi email.

   Se stai solo testando questa funzionalità, puoi inserire il tuo indirizzo email .

7. a concedere alle entità l'accesso alle risorse tramite Cloud Funzionalità di inoltro TCP di IAP, nell'elenco a discesa Ruolo seleziona Cloud IAP > Utente del tunnel con protezione IAP.

8. Fai clic su Salva.

gcloud

Per questo passaggio, utilizza le istruzioni della console.

Passaggio 5: accedi al nodo e verifica che non sia in grado di connettersi a internet

Console

1. Nella console Google Cloud, vai alla pagina Istanze VM.

   Vai alla pagina Istanze VM

2. Individua il nodo per il quale hai creato le autorizzazioni SSH IAP. Nella colonna Connetti, fai clic sul menu a discesa SSH. Freccia e seleziona Apri nella finestra del browser.

   Se è la prima volta che ti connetti all'istanza, Google Cloud genera le chiavi SSH per te.

3. Nel prompt del nodo, trova l'ID di processo del container kube-dns:

   pgrep '^kube-dns$'

4. Accedi al contenitore:

   sudo nsenter --target PROCESS_ID --net /bin/bash

5. Da kube-dns, prova a connetterti a internet:

   curl example.com

   Non dovrebbe essere restituito alcun risultato. In questo caso, potresti non aver creato di cluster come cluster privato o potrebbero verificarsi altri problemi. Per risolvere i problemi, vedi Le VM possono connettersi a internet in modo imprevisto senza Public NAT.

   Per terminare il comando, potresti dover inserire Ctrl+C.

gcloud

1. Trova il nome di uno dei nodi del cluster:

   gcloud compute instances list

   Il nome di un nodo è simile a gke-nat-test-cluster-default-pool-1a4cbd06-3m8v. Prendi nota il nome del nodo e utilizzalo ovunque NODE_NAME nei comandi seguenti.

2. Connettiti al nodo:

   gcloud compute ssh NODE_NAME \
       --zone us-east4-c \
       --tunnel-through-iap

3. Nel prompt del nodo, trova l'ID di processo del container kube-dns:

   pgrep '^kube-dns$'

4. Accedi al contenitore:

   sudo nsenter --target PROCESS_ID --net /bin/bash

5. Da kube-dns, prova a connetterti a internet:

   curl example.com

   Non dovrebbe essere visualizzato alcun risultato.Per terminare il comando, potresti dover inserire Ctrl+C.

Passaggio 6: crea una configurazione NAT utilizzando il router Cloud

Devi creare il router Cloud nella stessa regione delle istanze che utilizzano Public NAT. Public NAT viene utilizzato solo per inserire NAT sulle VM. Non viene utilizzato come parte dell'effettivo gateway NAT.

Questa configurazione consente a tutte le istanze nella regione di utilizzare Public NAT per tutti gli intervalli IP alias e principali. Inoltre, viene eseguito automaticamente alloca gli indirizzi IP esterni per il gateway NAT. Per ulteriori opzioni, vedi Consulta la documentazione di Google Cloud CLI.

Nota: il NAT pubblico utilizza il router Cloud solo per raggruppare NAT le informazioni sulla configurazione (piano di controllo). Il servizio NAT pubblico indicare a un router Cloud l'uso di BGP o di aggiungere route. Il traffico NAT non passano attraverso un router Cloud (piano dati).

Console

1. Nella console Google Cloud, vai alla pagina Cloud NAT.

   Vai alla pagina Cloud NAT

2. Fai clic su Inizia o Crea gateway NAT.

3. Inserisci nat-config nel campo Nome gateway.

4. Imposta la Rete VPC su custom-network1.

5. Imposta Regione su us-east4.

6. In Router Cloud, seleziona Crea nuovo router.

   1. Inserisci nat-router come nome.
   2. Fai clic su Crea.

7. Fai clic su Crea.

gcloud

1. Crea un router Cloud:

   gcloud compute routers create nat-router \
       --network custom-network1 \
       --region us-east4

2. Aggiungi una configurazione al router:

   gcloud compute routers nats create nat-config \
       --router-region us-east4 \
       --router nat-router \
       --nat-all-subnet-ip-ranges \
       --auto-allocate-nat-external-ips

Terraform

Puoi utilizzare una risorsa Terraform per creare un router Cloud.

resource "google_compute_router" "router" {
  project = var.project_id
  name    = "nat-router"
  network = var.network
  region  = "us-east4"
}

Puoi utilizzare un modulo Terraform per creare una configurazione NAT.

module "cloud-nat" {
  source                             = "terraform-google-modules/cloud-nat/google"
  version                            = "~> 5.0"
  project_id                         = var.project_id
  region                             = "us-east4"
  router                             = google_compute_router.router.name
  name                               = "nat-config"
  source_subnetwork_ip_ranges_to_nat = "ALL_SUBNETWORKS_ALL_IP_RANGES"
}

Passaggio 7: prova di nuovo a connetterti a internet

La propagazione della configurazione NAT potrebbe richiedere fino a tre minuti, quindi attendere almeno un minuto prima di riprovare ad accedere a internet.

Se non hai ancora eseguito l'accesso a kube-dns, esegui di nuovo la connessione seguendo la procedura nel Passaggio 5. Dopo aver effettuato l'accesso, esegui nuovamente il comando curl:

curl example.com

Dovresti vedere un output che include i seguenti contenuti:

<html>
<head>
<title>Example Domain</title>
...
...
...
</head>

<body>
<div>
    <h1>Example Domain</h1>
    <p>This domain is established to be used for illustrative examples in documents. You can use this
    domain in examples without prior coordination or asking for permission.</p>
    <p><a href="http://www.iana.org/domains/example">More information...</a></p>
</div>
</body>
</html>

Passaggi successivi

• Configura un gateway Public NAT.
• Crea una configurazione di Compute Engine di esempio.