Use o NAT público com o GKE

Esta página mostra como configurar uma configuração de NAT pública de exemplo com o Google Kubernetes Engine (GKE). Antes de configurar a NAT pública, leia a vista geral da NAT pública.

Pré-requisitos

Tem de fazer o seguinte antes de configurar o NAT público.

Obtenha autorizações de IAM

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

Configurar Google Cloud

Antes de começar, configure os seguintes itens em 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.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  3. Verify that billing is enabled for your Google Cloud project.

  4. Install the Google Cloud CLI.

  5. Se estiver a usar um fornecedor de identidade (IdP) externo, tem primeiro de iniciar sessão na CLI gcloud com a sua identidade federada.

  6. Para inicializar a CLI gcloud, execute o seguinte comando: 

    gcloud init

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

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  8. Verify that billing is enabled for your Google Cloud project.

  9. Install the Google Cloud CLI.

  10. Se estiver a usar um fornecedor de identidade (IdP) externo, tem primeiro de iniciar sessão na CLI gcloud com a sua identidade federada.

  11. Para inicializar a CLI gcloud, execute o seguinte comando: 

    gcloud init

    12. Configurar o exemplo do GKE

    Use este exemplo se quiser ver uma configuração simples de NAT público a funcionar com o GKE.

    Passo 1: crie uma rede VPC e uma sub-rede

    Se já tiver uma rede e uma sub-rede, pode ignorar este passo.

    Consola

    1. Na Google Cloud consola, aceda à página Redes VPC.

      Aceda à página Redes de VPC

    2. Clique em Criar rede de VPC.

    3. Introduza um Nome de custom-network1.

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

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

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

    7. Introduza um intervalo de endereços IP de 192.168.1.0/24.

    8. Clique em Concluído e, de seguida, em Criar.

    gcloud

    1. Crie uma nova rede de nuvem virtual privada (VPC) no modo personalizado no seu 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 da sub-rede para a sua 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

    Pode usar um módulo do Terraform para criar uma sub-rede e uma rede de nuvem privada virtual personalizadas.

    module "test-vpc-module" {
  source       = "terraform-google-modules/network/google"
  version      = "~> 10.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"
    }
  ]
}

    Passo 2: crie um cluster privado

    Consola

    1. Na Google Cloud consola, aceda à página Clusters do Kubernetes.

      Aceda à página de clusters do Kubernetes

    2. Clique em Criar cluster.

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

    4. Defina o Tipo de localização como Zonal.

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

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

    7. Selecione Cluster privado.

    8. Desmarque a caixa de verificação Aceder ao plano de controlo através do respetivo endereço IP externo.

    9. Introduza um intervalo de IPs do plano de controlo 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

    Pode usar um recurso do Terraform para criar um cluster privado.

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

    Passo 3: crie uma regra de firewall que permita ligações SSH

    Consola

    1. Na Google Cloud consola, aceda à página Políticas de firewall.

      Aceda à página Políticas de firewall

    2. Clique em Criar regra de firewall.

    3. Introduza um Nome de allow-ssh.

    4. Especifique uma rede de custom-network1.

    5. Defina Direction of traffic (Direção do tráfego) como Ingress (Entrada).

    6. Defina a opção Ação na correspondência como Permitir.

    7. Defina Segmentações como Todas as instâncias na rede.

    8. Defina o Filtro de origem como Intervalos IPv4.

    9. Defina os Intervalos IP de origem como 35.235.240.0/20.

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

    11. Selecione a caixa de verificação tcp e introduza 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

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

    Passo 4: crie autorizações de SSH de IAP para um dos seus nós

    Num passo posterior, use o IAP para estabelecer ligação ao seu nó.

    Consola

    1. Na Google Cloud consola, aceda à página Identity-Aware Proxy.

      Aceda à página Identity-Aware Proxy

    2. Selecione o separador Recursos de SSH e TCP.

    3. Selecione a caixa de verificação junto ao primeiro nó na lista em Todos os recursos de túnel > us-east4-c. O nome é semelhante a gke-nat-test-cluster-default-pool-b50db58d-075t.

    4. Anote o nome do nó. Mais tarde, vai usá-lo para testar a conetividade.

    5. No painel do lado direito, clique em Adicionar principal.

    6. Para conceder aos utilizadores, aos grupos ou às contas de serviço acesso aos recursos, no campo Novos membros, especifique os respetivos endereços de email.

      Se estiver apenas a testar esta funcionalidade, pode introduzir o seu próprio endereço de email.

    7. Para conceder aos responsáveis acesso aos recursos através da funcionalidade de encaminhamento TCP do Cloud IAP, na lista pendente Função, selecione Cloud IAP > Utilizador do túnel protegido pelo IAP.

    8. Clique em Guardar.

    gcloud

    Para este passo, use as instruções da consola.

    Passo 5: inicie sessão no nó e confirme que não consegue aceder à Internet

    Consola

    1. Na Google Cloud consola, aceda à página Instâncias de VM.

      Aceda à página de instâncias de VM

    2. Encontre o nó para o qual criou autorizações de SSH de IAP. Na coluna Ligar, clique na seta pendente SSH e, de seguida, selecione Abrir na janela do navegador.

      Se esta for a primeira vez que se liga à instância, o Google Cloud Google Cloud gera as chaves SSH por si.

    3. Na linha de comandos do nó, encontre o ID do processo do contentor kube-dns:

      pgrep '^kube-dns$'

    4. Aceda ao contentor:

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

    5. A partir de kube-dns, tente estabelecer ligação à Internet:

      curl example.com

      Não deve receber nenhum resultado. Se o fizer, pode não ter criado o cluster como um cluster privado ou pode haver outro problema. Para resolver problemas, consulte o artigo As VMs podem aceder à Internet inesperadamente sem NAT público.

      Para terminar o comando, pode ter de introduzir Ctrl+C.

    gcloud

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

      gcloud compute instances list

      Um nome de nó tem um aspeto semelhante a gke-nat-test-cluster-default-pool-1a4cbd06-3m8v. Tome nota do nome do nó e use esse nome sempre que vir NODE_NAME nos comandos seguintes.

    2. Estabeleça ligação ao nó:

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

    3. Na linha de comandos do nó, encontre o ID do processo do contentor kube-dns:

      pgrep '^kube-dns$'

    4. Aceda ao contentor:

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

    5. A partir de kube-dns, tente estabelecer ligação à Internet:

      curl example.com

      Não deve receber nenhum resultado.Para terminar o comando, pode ter de introduzir Ctrl+C.

    Passo 6: crie uma configuração de NAT com o Cloud Router

    Tem de criar o Cloud Router na mesma região que as instâncias que usam NAT pública. A NAT pública só é usada para colocar informações de NAT nas VMs. Não é usado como parte do gateway NAT real.

    Esta configuração permite que todas as instâncias na região usem o NAT público para todos os intervalos de IP de alias primários. Também atribui automaticamente os endereços IP externos para o gateway NAT. Para mais opções, consulte a documentação da CLI do Google Cloud.

    Consola

    1. Na Google Cloud consola, aceda à página Cloud NAT.

      Aceda à página do Cloud NAT

    2. Clique em Começar ou Criar gateway de NAT.

    3. Introduza um Nome da gateway de nat-config.

    4. Defina a rede de VPC como custom-network1.

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

    6. Em Cloud Router, selecione Criar novo router.

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

    7. Clique em Criar.

    gcloud

    1. Crie um Cloud Router:

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

    2. Adicione uma configuração ao 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

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

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

    Passo 7: tente estabelecer ligação à Internet novamente

    A propagação da configuração de NAT pode demorar até três minutos, por isso, aguarde, pelo menos, um minuto antes de tentar aceder novamente à Internet.

    Se ainda não tiver sessão iniciada no kube-dns, volte a ligar-se através do procedimento no passo 5. Depois de iniciar sessão, volte a executar o comando curl:

    curl example.com

    Deverá ver um resultado que contenha 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>

    O que se segue?