Como acessar clusters particulares do Google Kubernetes Engine com pools particulares do Cloud Build

Neste tutorial, descrevemos como acessar um cluster particular do Google Kubernetes Engine (GKE) usando pools particulares do Cloud Build. Esse acesso permite que você use o Cloud Build para implantar seu aplicativo em um cluster particular do GKE. Este tutorial é destinado a administradores de rede e é aplicável a todas as situações em que os pools particulares do Cloud Build precisam se comunicar com serviços executados em uma rede de nuvem privada virtual (VPC) com peering. Por exemplo, os workers do pool particular podem se comunicar com os seguintes serviços:

  • Cluster particular do GKE
  • Banco de dados do Cloud SQL
  • Instância do Memorystore
  • Instância do Compute Engine em execução em uma rede VPC diferente da que tem peering com o pool particular do Cloud Build

Os pools particulares do Cloud Build e os planos de controle do cluster do GKE são executados em redes VPC de propriedade do Google. Essas redes VPC têm peering com a sua própria rede VPC no Google Cloud. No entanto, o peering de rede VPC não é compatível com peering transitivo, o que pode representar uma restrição ao usar pools particulares do Cloud Build. Neste tutorial, apresentamos uma solução que usa o Cloud VPN para permitir que os workers em um pool particular do Cloud Build acessem o plano de controle de um cluster particular do GKE.

Neste tutorial, presumimos que você conheça o Google Kubernetes Engine, o Cloud Build, o comando gcloud, o peering de rede VPC e o Cloud VPN.

Visão geral da arquitetura

Quando você cria um cluster particular do GKE sem acesso de cliente ao endpoint público, os clientes só podem acessar o plano de controle do cluster do GKE usando o endereço IP particular. Clientes como kubectl só podem se comunicar com o plano de controle se forem executados em uma instância que tenha acesso à rede VPC e esteja em uma rede autorizada.

Se você quiser usar o Cloud Build para implantar seu aplicativo neste cluster particular do GKE, precisará usar pools particulares do Cloud Build para acessar os clusters do GKE. Os pools particulares são um conjunto de instâncias de worker executadas em um projeto do Google Cloud de propriedade do Google e que têm peering com a sua rede VPC usando uma conexão de peering de rede VPC. Nesta configuração, as instâncias de worker podem se comunicar com o endereço IP particular do plano de controle do cluster do GKE.

No entanto, o plano de controle de cluster do GKE também é executado em um projeto de propriedade do Google e está em peering com sua rede VPC usando uma conexão de peering. O peering de rede VPC não é compatível com o peering transitivo. Portanto, não é possível rotear os pacotes diretamente entre o pool particular do Cloud Build e o plano de controle do cluster do GKE.

Para permitir que as instâncias de worker do Cloud Build acessem o plano de controle do cluster do GKE, faça peering do pool particular e do plano do cluster do GKE com duas de suas redes VPC e conecte essas duas redes VPC que usam o Cloud VPN. Esse peering e essa conexão permitem que cada lado do túnel da VPC divulgue o pool particular e as redes do plano de controle do cluster do GKE, concluindo a rota.

O diagrama de arquitetura a seguir mostra os recursos usados neste tutorial:

Túnel VPN que conclui a rota entre o pool particular do Cloud Build e o plano de controle do cluster do GKE.

Recomendamos a criação de todos os recursos usados neste tutorial na mesma região do Google Cloud para ter baixa latência. O túnel VPN pode atravessar duas regiões diferentes se essa comunicação entre regiões for necessária para sua própria implementação. Suas duas redes VPC também podem pertencer a projetos diferentes.

Objetivos

  • Criar um cluster particular do GKE
  • Configurar um pool particular do Cloud Build
  • Criar uma conexão VPN de alta disponibilidade entre duas redes VPC
  • Ativar o roteamento de pacotes em dois peerings de rede VPC e em uma conexão VPC

Custos

Neste tutorial, usamos os seguintes componentes faturáveis do Google Cloud:

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem ser qualificados para uma avaliação gratuita.

Ao concluir este tutorial, exclua os recursos criados para evitar o faturamento contínuo. Para mais informações, consulte Como fazer a limpeza.

Antes de começar

  1. No Console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

    Acessar o seletor de projetos

  2. Verifique se o faturamento está ativado para seu projeto na nuvem. Saiba como confirmar se o faturamento está ativado para o projeto.

  3. Ative as APIs Cloud Build, Google Kubernetes Engine, and Service Networking.

    Ative as APIs

  4. No Console do Cloud, ative o Cloud Shell.

    Ativar o Cloud Shell

    Na parte inferior do Console do Cloud, uma sessão do Cloud Shell é iniciada e exibe um prompt de linha de comando. O Cloud Shell é um ambiente com o SDK do Cloud pré-instalado com a ferramenta de linha de comando gcloud e os valores já definidos para seu projeto atual. A inicialização da sessão pode levar alguns segundos.

Como criar duas redes VPC no seu próprio projeto

Nesta seção, você cria duas redes VPC e uma sub-rede para os nós do cluster do GKE.

  1. No Cloud Shell, crie a primeira rede VPC (chamada "Rede VPC de peering do pool particular" no diagrama anterior). Não é necessário criar sub-redes nesta rede.

    gcloud compute networks create PRIVATE_POOL_VPC_NAME \
        --subnet-mode=CUSTOM
    

    PRIVATE_POOL_VPC_NAME é o nome da sua rede VPC a ser pareada com a rede do pool particular do Cloud Build.

  2. Crie a segunda rede VPC (chamada "Rede VPC de peering do GKE" no diagrama anterior):

    gcloud compute networks create GKE_VPC_NAME \
        --subnet-mode=CUSTOM
    

    GKE_VPC_NAME é o nome da sua rede VPC a ser pareada com o plano de controle do cluster do GKE.

  3. Crie uma sub-rede para os nós do cluster do GKE:

    gcloud compute networks subnets create GKE_SUBNET_NAME \
        --network=GKE_VPC_NAME \
        --range=GKE_SUBNET_RANGE \
        --region=REGION
    

    Substitua o seguinte:

    • GKE_SUBNET_NAME: o nome da sub-rede que hospeda os nós do cluster do GKE.
    • GKE_SUBNET_RANGE: o intervalo de endereços IP de GKE_SUBNET_NAME. Neste tutorial, use 10.244.252.0/22.
    • REGION: a região do Google Cloud que hospeda o cluster do GKE. Neste tutorial, use us-central1.

Você configurou duas redes VPC no seu próprio projeto, e elas estão prontas para fazer peering com outros serviços.

Como criar um cluster particular do GKE

Nesta seção, você cria o cluster particular do GKE.

  1. No Cloud Shell, crie um cluster do GKE sem acesso de cliente ao endpoint público do plano de controle.

    gcloud container clusters create PRIVATE_CLUSTER_NAME \
        --region=REGION \
        --enable-master-authorized-networks \
        --network=GKE_VPC_NAME \
        --subnetwork=GKE_SUBNET_NAME \
        --enable-private-nodes \
        --enable-private-endpoint \
        --enable-ip-alias \
        --master-ipv4-cidr=CLUSTER_CONTROL_PLANE_CIDR
    

    Substitua o seguinte:

    • PRIVATE_CLUSTER_NAME: o nome do cluster particular do GKE.
    • CLUSTER_CONTROL_PLANE_CIDR: o intervalo de endereços IP do plano de controle do cluster do GKE. Ele precisa ter um prefixo /28. Neste tutorial, use 172.16.0.32/28.
    • REGION: a região do cluster do GKE. Neste tutorial, use us-central1 para a região, a mesma que você usou para as redes VPC.

    Você criou um cluster particular do GKE que tem peering com a rede VPC no seu próprio projeto.

  2. Recupere o nome do peering de rede VPC do cluster do GKE. Esse peering de rede VPC foi criado automaticamente quando você criou o cluster do GKE.

    export GKE_PEERING_NAME=$(gcloud container clusters describe PRIVATE_CLUSTER_NAME \
        --region=REGION \
        --format='value(privateClusterConfig.peeringName)')
    
  3. Ative a exportação de rotas personalizadas para divulgar a rede de pool particular para o plano de controle do cluster do GKE:

    gcloud compute networks peerings update $GKE_PEERING_NAME \
        --network=GKE_VPC_NAME \
        --export-custom-routes \
        --no-export-subnet-routes-with-public-ip
    

    Para mais informações sobre rotas personalizadas, leia Como importar e exportar rotas personalizadas.

Como criar um pool particular do Cloud Build

Nesta seção, você cria o pool particular do Cloud Build.

  1. No Cloud Shell, aloque um intervalo de endereços IP nomeado na rede VPC PRIVATE_POOL_VPC_NAME para o pool privado do Cloud Build:

    gcloud compute addresses create RESERVED_RANGE_NAME \
        --global \
        --purpose=VPC_PEERING \
        --addresses=PRIVATE_POOL_NETWORK \
        --prefix-length=PRIVATE_POOL_PREFIX \
        --network=PRIVATE_POOL_VPC_NAME
    

    Substitua o seguinte:

    • RESERVED_RANGE_NAME: o nome do intervalo de endereços IP particulares que hospeda o pool particular do Cloud Build.
    • PRIVATE_POOL_NETWORK: o primeiro endereço IP de RESERVED_RANGE_NAME. Neste tutorial, use 192.168.0.0.
    • PRIVATE_POOL_PREFIX: o prefixo de RESERVED_RANGE_NAME. Ele precisa ser maior que /24. Neste tutorial, use 16.
    • O intervalo de IP é global porque, quando --purpose é VPC_PEERING, o intervalo de endereços IP nomeado precisa ser global.
  2. Crie uma conexão particular entre a rede VPC do pool particular e PRIVATE_POOL_VPC_NAME:

    gcloud services vpc-peerings connect \
        --service=servicenetworking.googleapis.com \
        --ranges=RESERVED_RANGE_NAME \
        --network=PRIVATE_POOL_VPC_NAME
    
  3. Ative a exportação de rotas personalizadas para anunciar a rede do plano de controle de cluster do GKE para o pool privado:

    gcloud compute networks peerings update servicenetworking-googleapis-com \
        --network=PRIVATE_POOL_VPC_NAME \
        --export-custom-routes \
        --no-export-subnet-routes-with-public-ip
    
  4. Crie um pool particular do Cloud Build que esteja em peering com PRIVATE_POOL_VPC_NAME:

    gcloud builds worker-pools create PRIVATE_POOL_NAME \
       --region=REGION \
       --peered-network=projects/$GOOGLE_CLOUD_PROJECT/global/networks/PRIVATE_POOL_VPC_NAME
    

    PRIVATE_POOL_NAME é o nome do pool particular do Cloud Build.

Você criou um pool particular do Cloud Build e fez o peering dele com a rede VPC no seu próprio projeto.

Como criar uma conexão do Cloud VPN entre as duas redes VPC

No seu próprio projeto, agora você tem uma rede VPC em peering com o pool particular do Cloud Build e uma segunda rede VPC em peering com o cluster particular do GKE.

Nesta seção, você cria uma conexão do Cloud VPN entre as duas redes VPC do seu projeto. Essa conexão conclui a rota e permite que os pools particulares do Cloud Build acessem o cluster do GKE.

  1. No Cloud Shell, crie dois gateways de VPN de alta disponibilidade que se conectam. Para criar esses gateways, siga as instruções em Como criar dois gateways de VPN de alta disponibilidade que se interconectam. A configuração é concluída após a criação das sessões do BGP. Enquanto você estiver seguindo as instruções, use estes valores:

    • PRIVATE_POOL_VPC_NAME para NETWORK_1
    • GKE_VPC_NAME para NETWORK_2
    • REGION para REGION_1 e REGION_2
  2. Configure cada uma das quatro sessões do BGP que você criou para anunciar as rotas para a rede VPC do pool particular e a rede VPC do plano de controle do cluster do GKE:

    gcloud compute routers update-bgp-peer ROUTER_NAME_1 \
        --peer-name=PEER_NAME_GW1_IF0 \
        --region=REGION \
        --advertisement-mode=CUSTOM \
        --set-advertisement-ranges=PRIVATE_POOL_NETWORK/PRIVATE_POOL_PREFIX
    
    gcloud compute routers update-bgp-peer ROUTER_NAME_1 \
        --peer-name=PEER_NAME_GW1_IF1 \
        --region=REGION \
        --advertisement-mode=CUSTOM \
        --set-advertisement-ranges=PRIVATE_POOL_NETWORK/PRIVATE_POOL_PREFIX
    
    gcloud compute routers update-bgp-peer ROUTER_NAME_2 \
        --peer-name=PEER_NAME_GW2_IF0 \
        --region=REGION \
        --advertisement-mode=CUSTOM \
        --set-advertisement-ranges=CLUSTER_CONTROL_PLANE_CIDR
    
    gcloud compute routers update-bgp-peer ROUTER_NAME_2 \
        --peer-name=PEER_NAME_GW2_IF1 \
        --region=REGION \
        --advertisement-mode=CUSTOM \
        --set-advertisement-ranges=CLUSTER_CONTROL_PLANE_CIDR
    

    Onde os seguintes valores são os mesmos nomes que você usou quando criou os dois gateways de VPN de alta disponibilidade:

    • ROUTER_NAME_1
    • PEER_NAME_GW1_IF0
    • PEER_NAME_GW1_IF1
    • ROUTER_NAME_2
    • PEER_NAME_GW2_IF0
    • PEER_NAME_GW2_IF1

Como ativar o acesso do Cloud Build ao plano de controle do cluster do GKE

Agora que você tem uma conexão VPN entre as duas redes VPC no projeto, ative o acesso do Cloud Build ao plano de controle do cluster do GKE.

  1. No Cloud Shell, adicione o intervalo de rede do pool particular às redes autorizadas do plano de controle no GKE:

    gcloud container clusters update PRIVATE_CLUSTER_NAME \
        --enable-master-authorized-networks \
        --region=REGION \
        --master-authorized-networks=PRIVATE_POOL_NETWORK/PRIVATE_POOL_PREFIX
    

    Substitua o seguinte:

    • PRIVATE_POOL_NETWORK: o primeiro endereço IP de RESERVED_RANGE_NAME. Neste tutorial, use 192.168.0.0.
    • PRIVATE_POOL_PREFIX: o prefixo de RESERVED_RANGE_NAME. Ele precisa ser maior que /24. Neste tutorial, use 16.
  2. Permita que a conta de serviço do Cloud Build acesse o plano de controle do cluster do GKE:

    export PROJECT_NUMBER=$(gcloud projects describe $GOOGLE_CLOUD_PROJECT --format 'value(projectNumber)')
    
    gcloud projects add-iam-policy-binding $GOOGLE_CLOUD_PROJECT \
        --member=serviceAccount:$PROJECT_NUMBER@cloudbuild.gserviceaccount.com \
        --role=roles/container.developer
    

Agora os pools particulares do Cloud Build podem acessar o plano de controle do cluster do GKE.

Como verificar a solução

Esta seção ajuda a verificar se a solução está funcionando. Para isso, você executará o comando kubectl get nodes em uma etapa de criação executada no pool particular.

  1. No Cloud Shell, crie uma pasta temporária com um arquivo de configuração do Cloud Build que executa o comando kubectl get nodes:

    mkdir private-pool-test && cd private-pool-test
    
    cat > cloudbuild.yaml <<EOF
    steps:
    - name: "gcr.io/cloud-builders/kubectl"
      args: ['get', 'nodes']
      env:
      - 'CLOUDSDK_COMPUTE_REGION=REGION'
      - 'CLOUDSDK_CONTAINER_CLUSTER=PRIVATE_CLUSTER_NAME'
    options:
      workerPool:
        'projects/$GOOGLE_CLOUD_PROJECT/locations/REGION/workerPools/PRIVATE_POOL_NAME'
    EOF
    
  2. Inicie o job de criação:

    gcloud builds submit --config=cloudbuild.yaml
    
  3. Verifique se a saída é a lista de nós no cluster do GKE. O registro de criação mostrado no console inclui uma tabela semelhante a esta:

    NAME                                     STATUS   ROLES    AGE   VERSION
    gke-private-default-pool-3ec34262-7lq9   Ready    <none>   9d    v1.19.9-gke.1900
    gke-private-default-pool-4c517758-zfqt   Ready    <none>   9d    v1.19.9-gke.1900
    gke-private-default-pool-d1a885ae-4s9c   Ready    <none>   9d    v1.19.9-gke.1900
    

Agora você verificou que os workers do pool particular podem acessar o cluster do GKE. Esse acesso permite que você use o Cloud Build para implantar seu aplicativo neste cluster particular do GKE.

Solução de problemas

Se você tiver problemas com este tutorial, consulte os seguintes documentos:

Limpeza

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados no tutorial, exclua o projeto que os contém ou mantenha o projeto e exclua os recursos individuais.

Exclua o projeto

  1. No Console do Cloud, acesse a página Gerenciar recursos:

    Acessar "Gerenciar recursos"

  2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
  3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

Excluir recursos individuais

  1. No Cloud Shell, exclua o cluster do GKE:

    gcloud container clusters delete PRIVATE_CLUSTER_NAME \
        --region=REGION \
        --async
    

    Quando você executa esse comando, o peering de redes VPC é excluído automaticamente.

  2. Exclua o pool particular do Cloud Build:

    gcloud builds worker-pools delete PRIVATE_POOL_NAME \
        --region=REGION
    
  3. Exclua a conexão particular entre a rede VPC do produtor de serviços e PRIVATE_POOL_VPC_NAME:

    gcloud services vpc-peerings delete \
       --network=PRIVATE_POOL_VPC_NAME \
       --async
    
  4. Exclua o intervalo de endereços IP nomeado usado para o pool particular:

    gcloud compute addresses delete RESERVED_RANGE_NAME \
        --global
    
  5. Exclua os quatro túneis de VPN. Use os mesmos nomes especificados em Criar túneis de VPN.

    gcloud compute vpn-tunnels delete \
        TUNNEL_NAME_GW1_IF0 \
        TUNNEL_NAME_GW1_IF1 \
        TUNNEL_NAME_GW2_IF0 \
        TUNNEL_NAME_GW2_IF1 \
        --region=REGION
    
  6. Exclua os dois Cloud Routers. Use os mesmos nomes especificados em Criar roteadores do Cloud Router.

    gcloud compute routers delete \
        ROUTER_NAME_1 \
        ROUTER_NAME_2 \
        --region=REGION
    
  7. Exclua os dois gateways de VPN. Use os mesmos nomes que você especificou em Criar os gateways de VPN de alta disponibilidade.

    gcloud compute vpn-gateways delete \
        GW_NAME_1 \
        GW_NAME_2 \
        --region=REGION
    
  8. Exclua GKE_SUBNET_NAME: a sub-rede que hospeda os nós do cluster do GKE:

    gcloud compute networks subnets delete GKE_SUBNET_NAME \
        --region=REGION
    
  9. Exclua as duas redes VPC PRIVATE_POOL_VPC_NAME e GKE_VPC_NAME:

    gcloud compute networks delete \
        PRIVATE_POOL_VPC_NAME \
        GKE_VPC_NAME
    

A seguir