Usar Public NAT com o GKE

Esta página mostra como configurar um exemplo de configuração do Public NAT com o Google Kubernetes Engine (GKE). Antes de configurar o Public NAT, leia a Visão geral do Public NAT.

Pré-requisitos

É necessário fazer o seguinte antes de configurar o Public NAT.

Acessar permissões do IAM

O papel roles/compute.networkAdmin concede permissões para criar um gateway NAT no Cloud Router, reservar e atribuir endereços IP de NAT e especificar sub-redes (sub-redes) cujo tráfego deve usar a conversão de endereços de rede pelo gateway NAT.

Configurar o Google Cloud

Antes de começar, configure os seguintes itens no Google Cloud.

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

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. Make sure that billing is enabled for your Google Cloud project.

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. Make sure that billing is enabled for your Google Cloud project.

8. Install the Google Cloud CLI.

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

   gcloud init

Observação:

As instruções da CLI do Google Cloud nesta página presumem que você tenha definido o ID do projeto antes de emitir comandos. Configure um ID de projeto com o seguinte comando:

    gcloud config set project PROJECT_ID
  

É possível também ver um ID projeto já configurado:

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

Como configurar o exemplo do GKE

Use este exemplo se você quiser ver uma configuração simples do Public NAT funcionando com o GKE.

Etapa 1: criar uma rede e sub-rede da VPC

Se você já tiver uma rede e uma sub-rede, pule esta etapa.

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

   Observação: por se tratar de uma rede VPC, não há nenhum intervalo de IPv4 ou endereço IP de gateway no nível da rede, então nada será exibido.
   .

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

Etapa 2: criar um cluster particular

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

Etapa 3: criar uma regra de firewall que permita conexões SSH

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

Etapa 4: criar permissões SSH via IAP para um de seus nós

Em uma etapa posterior, use o IAP para se conectar ao seu nó.

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.

Etapa 5: fazer login no nó e confirmar que não é possível acessar a Internet

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.

Etapa 6: criar uma configuração NAT usando o Cloud Router

É necessário criar o Cloud Router na mesma região que as instâncias que usam o Public NAT. O Public NAT é usado apenas para colocar informações NAT nas VMs. Ele não é usado como parte do gateway NAT real.

Essa configuração permite que todas as instâncias da região usem o Public NAT para todos os intervalos de IP alias e primário. Ela também aloca automaticamente os endereços IP externos para o gateway NAT. Para mais opções, consulte a documentação da CLI do Google Cloud.

Observação: o Public NAT usa o Cloud Router apenas para agrupar informações de configuração do NAT (plano de controle). O Public NAT não direciona um Cloud Router para usar o BGP ou para adicionar rotas. O tráfego NAT não passa porum Cloud Router (plano de dados).

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

Etapa 7: tentar se conectar à Internet novamente

Pode levar até três minutos para que a configuração de NAT seja propagada. Portanto, aguarde pelo menos um minuto antes de tentar acessar a Internet novamente.

Se você ainda não tiver feito login no kube-dns, reconecte usando o procedimento na Etapa 5. Depois de fazer login, execute novamente o comando curl:

curl example.com

Você verá a saída que contém o seguinte conteúdo:

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

A seguir

• Configurar um gateway do Public NAT.
• Criar um Exemplo de configuração do Compute Engine.