Como criar clusters particulares do GKE com proxies de rede para acesso mestre

Quando você cria um cluster particular do GKE com um endpoint mestre, não é possível acessar o nó mestre do cluster pela Internet pública. No entanto, é necessário que ele possa ser acessado para fins de administração.

Por padrão, os clusters podem acessar o mestre por meio do respectivo endpoint privado, e é possível definir redes autorizadas na VPC. No entanto, o mestre não pode ser acessado por meio de outra conexão de peering de rede VPC (como em configurações hub e spoke), exceto por meio de um proxy que você cria e hospeda no espaço de endereços IP autorizados.

Neste tutorial, você aprenderá a configurar esse proxy no seu cluster particular do GKE.

Objetivos

  • Criar um cluster particular do GKE sem acesso externo.
  • Criar e implantar uma imagem do Docker para executar o proxy.
  • Criar um serviço Kubernetes para acessar o proxy.
  • Testar o acesso ao proxy.

Custos

Neste tutorial, há componentes do Google Cloud Platform passíveis de cobrança, entre eles:

Use a calculadora de preços para gerar uma estimativa de custo com base no uso previsto.

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. Faça login na sua Conta do Google.

    Se você ainda não tiver uma, inscreva-se.

  2. Selecione ou crie um projeto do Google Cloud Platform.

    Acessar a página Gerenciar recursos

  3. Verifique se o faturamento foi ativado no projeto do Google Cloud Platform.

    Saiba como ativar o faturamento

  4. Ativar Compute Engine and Google Kubernetes Engine APIs.

    Ativar as APIs

Como configurar o ambiente

Neste tutorial, use o Cloud Shell para inserir comandos. O Cloud Shell dá acesso à linha de comando no Console do GCP e inclui o SDK do Cloud e outras ferramentas necessárias para o desenvolvimento no GCP. O Cloud Shell é exibido como uma janela na parte inferior do Console do GCP. A inicialização leva alguns minutos, mas a janela aparece imediatamente.

Siga estas etapas para configurar seu ambiente usando o Cloud Shell:

  1. No Console do GCP, abra o Cloud Shell.

    Abrir o Cloud Shell

  2. Verifique se você está trabalhando no projeto criado ou selecionado. Substitua [YOUR_PROJECT_ID] pelo projeto do GCP.

    gcloud config set project [YOUR_PROJECT_ID]
    export PROJECT_ID=`gcloud config list --format="value(core.project)"`
    
  3. Defina a zona de computação padrão. Para os fins deste tutorial, é us-east1. Se você estiver implantando em um ambiente de produção, implante em uma região de sua escolha.

    gcloud config set compute/region us-central1
    gcloud config set compute/zone us-central1-c
    export REGION=us-central1
    export ZONE=us-central1-c
    
    

Como criar uma rede VPC e uma VM cliente

Crie uma rede e uma sub-rede VPC para hospedar os recursos.

  1. Crie uma rede VPC:

    gcloud compute networks create k8s-proxy --subnet-mode=custom
    
  2. Crie uma sub-rede personalizada na rede VPC recém-criada:

    gcloud compute networks subnets create subnet-cluster \
        --network=k8s-proxy --range=10.50.0.0/16
    
  3. Crie uma VM cliente que você usará para implantar recursos no cluster do Kubernetes:

    gcloud compute instances create --subnet=subnet-cluster \
        --scopes cloud-platform proxy-temp
    
  4. Salve o endereço IP interno da instância recém-criada em uma variável de ambiente:

    export CLIENT_IP=`gcloud compute instances describe proxy-temp \
        --format="value(networkInterfaces[0].networkIP)"`
    
  5. Crie uma regra de firewall para permitir o acesso SSH à rede VPC:

    gcloud compute firewall-rules create k8s-proxy-ssh --network k8s-proxy \
        --allow tcp:22
    

Como criar um cluster particular

Agora, crie um cluster particular para usar neste tutorial.

Se você já tiver um cluster de sua preferência, poderá ignorar a etapa de criação, mas terá que configurar alguma maneira inicial de acesso na máquina cliente.

  • No Cloud Shell, crie um cluster:

    gcloud container clusters create frobnitz  \
        --master-ipv4-cidr=172.16.0.64/28 \
        --network k8s-proxy \
        --subnetwork=subnet-cluster \
        --enable-ip-alias \
        --enable-private-nodes \
        --enable-private-endpoint \
        --master-authorized-networks $CLIENT_IP/32 \
        --enable-master-authorized-networks
    

    O comando cria um cluster particular do GKE denominado frobnitz. Ele tem redes autorizadas pelo mestre e configuradas para permitir que apenas a máquina cliente tenha acesso.

Como criar a imagem do Docker

Use as etapas a seguir para criar uma imagem de proxy da API do Kubernetes chamada k8s-api-proxy,, que atua como um proxy de encaminhamento para o servidor da API do Kubernetes.

  1. No Cloud Shell, crie um diretório e mude para ele:

    mkdir k8s-api-proxy && cd k8s-api-proxy
  2. Crie o Dockerfile. A configuração a seguir cria um contêiner do Alpine, que é uma distribuição de contêineres leve com um proxy Privoxy. O Dockerfile também instala curl e jq para a inicialização do contêiner, inclui os arquivos de configuração necessários, expõe a porta 8118 ao GKE internamente e inclui um script de inicialização.

    FROM alpine
    RUN apk add -U curl privoxy jq && \ mv /etc/privoxy/templates /etc/privoxy-templates && \ rm -rf /var/cache/apk/* /etc/privoxy/* && \ mv /etc/privoxy-templates /etc/privoxy/templates ADD --chown=privoxy:privoxy config \ /etc/privoxy/ ADD --chown=privoxy:privoxy k8s-only.action \ /etc/privoxy/ ADD --chown=privoxy:privoxy k8s-rewrite-internal.filter \ /etc/privoxy/ ADD k8s-api-proxy.sh /
    EXPOSE 8118/tcp
    ENTRYPOINT ["./k8s-api-proxy.sh"]
  3. No diretório k8s-api-proxy, crie o arquivo config e inclua o seguinte conteúdo nele:

    #config directory
    confdir /etc/privoxy
    # Allow Kubernetes API access only
    actionsfile /etc/privoxy/k8s-only.action
    # Rewrite https://CLUSTER_IP to https://kubernetes.default
    filterfile /etc/privoxy/k8s-rewrite-internal.filter
    # Don't show the pod name in errors
    hostname k8s-privoxy
    # Bind to all interfaces, port :8118
    listen-address  :8118
    # User cannot click-through a block
    enforce-blocks 1
    # Allow more than one outbound connection
    tolerate-pipelining 1
    
  4. No mesmo diretório, crie o arquivo k8s-only.action e inclua o conteúdo a seguir nele. Observe que CLUSTER_IP será substituído quando k8s-api-proxy.sh for executado.

    # Block everything...
    {+block{Not Kubernetes}}
    /
    # ... except the internal k8s endpoint, which you rewrite (see # k8s-rewrite-internal.filter). {+client-header-filter{k8s-rewrite-internal} -block{Kubernetes}} CLUSTER_IP/
  5. Crie o arquivo k8s-rewrite-internal.filter e inclua o conteúdo a seguir nele. Observe que CLUSTER_IP será substituído quando k8s-api-proxy.sh for executado.

    CLIENT-HEADER-FILTER: k8s-rewrite-internal\
     Rewrite https://CLUSTER_IP/ to https://kubernetes.default/
    s@(CONNECT) CLUSTER_IP:443\
     (HTTP/\d\.\d)@$1 kubernetes.default:443 $2@ig
    
  6. Crie o arquivo k8s-api-proxy.sh e inclua o conteúdo a seguir nele.

    #!/bin/sh
    
    set -o errexit
    set -o pipefail
    set -o nounset
    
    # Get the internal cluster IP
    INTERNAL_IP=$(curl -k -SsL https://kubernetes.default/api |
     jq -r '.serverAddressByClientCIDRs[0].serverAddress')
    
    # Replace CLUSTER_IP in the rewrite filter and action file
    sed -i "s/CLUSTER_IP/${INTERNAL_IP}/g"\
     /etc/privoxy/k8s-rewrite-internal.filter
    sed -i "s/CLUSTER_IP/${INTERNAL_IP}/g"\
     /etc/privoxy/k8s-only.action
    
    # Start Privoxy un-daemonized
    privoxy --no-daemon /etc/privoxy/config
    
  7. Torne o k8s-api-proxy.sh executável:

    chmod +x k8s-api-proxy.sh
  8. Crie e envie o contêiner para o projeto.

    docker build -t gcr.io/$PROJECT_ID/k8s-api-proxy:0.1 .
    docker push gcr.io/$PROJECT_ID/k8s-api-proxy:0.1
    

Como implantar a imagem e o serviço

  1. No Cloud Shell, faça login na VM cliente criada anteriormente:

    gcloud compute ssh proxy-temp
    
  2. Instale a ferramenta kubectl:

    sudo apt-get install kubectl
    
  3. Salve o ID do projeto como uma variável de ambiente:

    export PROJECT_ID=`gcloud config list --format="value(core.project)"`
    
  4. Consiga as credenciais do cluster:

    gcloud container clusters get-credentials frobnitz \
    --zone us-central1-c --internal-ip
    
  5. Crie uma implantação do Kubernetes que exponha o contêiner que você acabou de criar:

    kubectl run k8s-api-proxy \
        --image=gcr.io/$PROJECT_ID/k8s-api-proxy:0.1 \
        --port=8118
    
  6. Crie o arquivo ilb.yaml para o balanceador de carga interno e copie as seguintes instruções para ele:

    apiVersion: v1
    kind: Service
    metadata:
      labels:
        run: k8s-api-proxy
      name: k8s-api-proxy
      namespace: default
      annotations:
        cloud.google.com/load-balancer-type: "Internal"
    spec:
      ports:
      - port: 8118
        protocol: TCP
        targetPort: 8118
      selector:
        run: k8s-api-proxy
      type: LoadBalancer
    
  7. Implante o balanceador de carga interno:

    kubectl create -f ilb.yaml
  8. Verifique o serviço e aguarde um endereço IP:

    kubectl get service/k8s-api-proxy

    A saída será semelhante à exibida a seguir. Quando você vê um IP externo, o proxy está pronto.

    NAME            TYPE           CLUSTER-IP     EXTERNAL-IP   PORT(S)          AGE
    k8s-api-proxy   LoadBalancer   10.24.13.129   10.24.24.3    8118:30282/TCP   2m
    

    O endereço IP externo desta etapa é o endereço do proxy.

  9. Salve o endereço IP do ILB como uma variável de ambiente:

    export LB_IP=`kubectl get  service/k8s-api-proxy \
    -o jsonpath='{.status.loadBalancer.ingress[].ip}'`
    
  10. Salve o endereço IP mestre do cluster em uma variável de ambiente:

    export MASTER_IP=`gcloud container clusters describe frobnitz \
    --zone=us-central1-c \
    --format="get(privateClusterConfig.privateEndpoint)"`
    
  11. Acesse a API do Kubernetes por meio proxy vara verificar se ele é utilizável:

    curl -k -x $LB_IP:8118 https://$MASTER_IP/api
    
    O resultado será semelhante ao exibido a seguir:
    {
      "kind": "APIVersions",
      "versions": [
        "v1"
      ],
      "serverAddressByClientCIDRs": [
        {
          "clientCIDR": "0.0.0.0/0",
          "serverAddress": "172.16.0.66:443"
        }
      ]
    }
    
  12. Configure a variável de ambiente https_proxy para o proxy HTTP para que o comando kubectl possa alcançar o balanceador de carga interno de qualquer lugar.

    export https_proxy=$LB_IP:8118
  13. Execute o comando kubectl para testar seu proxy e a variável https_proxy:

    kubectl get pods

    Você terá um resultado parecido com o seguinte, o que significa que você conectou-se com êxito à API do Kubernetes por meio do proxy:

    NAME                             READY   STATUS    RESTARTS   AGE
    k8s-api-proxy-766c69dd45-mfqf4   1/1     Running   0          6m15s
    
  14. Saia da VM cliente:

    exit

Como fazer a limpeza

Para evitar que os recursos usados neste tutorial sejam cobrados na conta do Google Cloud Platform, faça o seguinte:

Excluir o projeto

  1. No Console do GCP, acesse a página "Projetos".

    Acessar a página Projetos

  2. Na lista de projetos, selecione um e clique em Excluir projeto.
  3. Na caixa de diálogo, digite o código do projeto e clique em Encerrar para excluí-lo.

A seguir

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…