Usar Public NAT com o GKE

Console

1. No Console do Google Cloud, acesse a página Redes VPC.

   Acessar a página "Redes VPC"

2. Clique em Criar rede VPC.

3. Informe um Nome de custom-network1.

4. Em Sub-redes, defina o Modo de criação da sub-rede como Personalizado.

5. Em Nova sub-rede, insira um Nome de subnet-us-east-192.

6. Em Região, selecione us-east4.

7. Digite um intervalo de endereço IP 192.168.1.0/24.

8. Clique em Concluído e em Criar.

gcloud

1. Crie uma nova rede de nuvem privada virtual (VPC) no modo personalizado no projeto:

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

   Saída:

   NAME             MODE     IPV4_RANGE   GATEWAY_IPV4
   custom-network1  custom

   .

2. Especifique o prefixo de sub-rede da primeira região. Neste exemplo, atribuímos 192.168.1.0/24 à região us-east4.

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

   Saída:

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

Terraform

É possível usar um módulo do Terraform para criar uma rede e uma sub-rede de nuvem privada virtual personalizada.

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"
    }
  ]
}

Console

1. No Console do Google Cloud, acesse a página de clusters do Kubernetes.

   Acessar a página de clusters do Kubernetes

2. Clique em Criar cluster.

3. Em Nome, insira nat-test-cluster.

4. Defina o Tipo de local como Zonal.

5. Defina a Zona como us-east4-c.

6. No painel de navegação, clique em Rede.

7. Selecione Cluster particular.

8. Desmarque a caixa de seleção Acesso ao plano de controle usando o endereço IP externo.

9. Insira um intervalo de IP do plano de controle de 172.16.0.0/28.

10. Defina Rede como custom-network1.

11. Para criar e iniciar o cluster, clique em Criar.

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

Use um recurso do Terraform para criar um cluster particular.

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

Console

1. No Console do Google Cloud, acesse a página Firewall.

   Acessar a página "Políticas de firewall"

2. Clique em Criar regra de firewall.

3. Informe um Nome de allow-ssh.

4. Especifique uma rede de custom-network1.

5. Defina a Direção do tráfego como Entrada.

6. Defina a Ação se houver correspondência como Permitir.

7. Defina Destinos como Todas as instâncias na rede.

8. Defina Filtro de origem como Intervalos IPv4.

9. Defina Intervalos de IPs de origem como 35.235.240.0/20.

10. Defina Protocolos e portas como Protocolos e portas especificados.

11. Marque a caixa de seleção tcp e insira a porta 22.

12. Clique em Criar

gcloud

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

Terraform

Use um recurso do Terraform para criar uma regra de 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"]
}

Console

1. No console do Google Cloud, acesse a página Identity-Aware Proxy.

   Acessar a página Identity-Aware Proxy

2. Selecione a guia Recursos SSH e TCP.

3. Marque a caixa de seleção ao lado do primeiro nó da lista em Todos os recursos do túnel > us-east4-c. Seu nome será semelhante a gke-nat-test-cluster-default-pool-b50db58d-075t.

4. Anote o nome do nó. Posteriormente, você o usará para testar a conectividade.

5. No painel à direita, clique em Adicionar principal.

6. Para conceder aos usuários, grupos ou contas de serviço acesso aos recursos, no campo Novos principais, especifique os endereços de e-mail.

   Se você estiver apenas testando esse recurso, poderá inserir seu próprio endereço de e-mail.

7. Para conceder aos principais acesso aos recursos por meio do recurso de encaminhamento TCP do Cloud IAP, na lista suspensa Papel, selecione Cloud IAP > Usuário do túnel protegido pelo IAP.

8. Clique em Save.

gcloud

Para esta etapa, use as instruções do Console.

Console

1. No console do Google Cloud, acesse a página Instâncias de VMs.

   Acessar a página "Instâncias de VM"

2. Encontre o nó em que você criou permissões SSH IAP. Na coluna Conectar, clique na seta suspensa SSH e selecione Abrir na janela do navegador.

   Se esta for a primeira vez que você se conecta à instância, o Google Cloud gera as chaves SSH para você.

3. No prompt do nó, encontre o código do processo do contêiner kube-dns:

   pgrep '^kube-dns$'

4. Acesse o contêiner:

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

5. A partir de kube-dns, tente se conectar à Internet:

   curl example.com

   Você não deve obter nenhum resultado. Se fizer isso, talvez você não tenha criado o cluster como um cluster particular ou pode haver algum outro problema. Para resolver esse problema, consulte As VMs podem acessar a Internet inesperadamente sem o Public NAT.

   Para finalizar o comando, talvez seja necessário inserir Ctrl+C.

gcloud

1. Encontre o nome de um dos nós do cluster:

   gcloud compute instances list

   O nome de um nó é semelhante a gke-nat-test-cluster-default-pool-1a4cbd06-3m8v. Anote o nome do nó e use-o sempre que aparecer NODE_NAME nos comandos a seguir.

2. Conectar-se ao nós:

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

3. No prompt do nó, encontre o código do processo do contêiner kube-dns:

   pgrep '^kube-dns$'

4. Acesse o contêiner:

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

5. A partir de kube-dns, tente se conectar à Internet:

   curl example.com

   Nenhum resultado será exibido. Para finalizar o comando, talvez seja necessário inserir Ctrl+C.

Console

1. No Console do Google Cloud, acesse a página do Cloud NAT.

   Acesse a página do Cloud NAT

2. Clique em Primeiros passos ou Criar gateway NAT.

3. Digite um nome de gateway de nat-config.

4. Defina a Rede VPC para custom-network1.

5. Defina a Região como us-east4.

6. Em Cloud Router, selecione Criar novo roteador.

   1. Informe um Nome de nat-router.
   2. Clique em Criar

7. Clique em Criar.

gcloud

1. Criar um Cloud Router

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

2. Adicionar uma configuração ao roteador

   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

É possível usar um recurso do Terraform para criar um Cloud Router.

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

Use um módulo do Terraform para criar uma configuração 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"
}