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

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. Neste tutorial, mostramos como configurar um mestre de um cluster particular do GKE para que ele não seja acessado de fora da rede, exceto por meio de um proxy criado e hospedado em um espaço de IP privado.

É possível configurar um proxy em vez de rotear o serviço do Kubernetes por meio de um balanceador de carga interno no cluster. Isso permite que você recupere as credenciais usando gcloud container clusters get-credentials e preserva o acesso ao mestre por meio de uma conexão segura.

Objetivos

  • Criar um cluster particular do GKE com acesso externo mínimo.
  • Criar e implantar uma imagem do Docker para executar o proxy.
  • Criar um serviço Kubernetes para acessar o proxy.
  • Remover todos os outros acessos externos ao cluster.

Custos

Neste tutorial, usamos componentes faturáveis do Google Cloud Platform, incluindo:

O custo estimado para essa solução é de aproximadamente US$ 2,42 por dia.

Antes de começar

  1. Selecione ou crie um projeto do GCP.

    Acessar a página Gerenciar recursos

  2. Verifique se o faturamento foi ativado para o projeto.

    Saiba como ativar o faturamento

  3. Você precisa ter uma máquina cliente com a seguinte configuração:
    • Um endereço IP externo conhecido para acesso inicial ao cluster. Isso é temporário, porque depois que seu proxy estiver configurado, você fornecerá acesso a um intervalo do CIDR. Um exemplo é uma máquina virtual do Compute Engine com um endereço IP externo. Você também precisa ter permissão para criar clusters e implantar pods e serviços.
    • Docker instalado e autenticado no gcr.io usando o gcloud auth configure-docker.

Ao concluir este tutorial, exclua os recursos criados para evitar a continuidade no faturamento. Veja mais detalhes em Como fazer a limpeza.

Como criar um cluster particular

O primeiro passo é criar ou selecionar 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.

  1. Para criar um cluster, execute o comando a seguir. Para [YOUR_CLIENT_IP_ADDRESS], use o endereço IP externo e roteável ou o netblock do cliente.

    gcloud container clusters create frobnitz  \
        --zone=us-central1-c \
        --master-ipv4-cidr=172.16.0.64/28 \
        --enable-ip-alias \
        --enable-private-nodes \
        --master-authorized-networks [YOUR_CLIENT_IP_ADDRESS]/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.

  2. Se você já tiver um cluster e quiser conceder acesso a ele, execute o comando a seguir. Para [YOUR_CLIENT_IP_ADDRESS], use o endereço IP externo e roteável ou o netblock do cliente. [CLUSTER_NAME] é o nome do cluster existente.

    gcloud container clusters update [CLUSTER_NAME] \
        --zone [CLUSTER_ZONE] \
        --enable-master-authorized-networks \
        --master-authorized-networks=[YOUR_CLIENT_IP_ADDRESS]/32

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. Na máquina cliente, 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-external.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:

    # Allow Kubernetes API access only
    actionsfile /etc/privoxy/k8s-only.action
    # Rewrite https://CLUSTER_IP to https://kubernetes.default
    filterfile /etc/privoxy/k8s-rewrite-external.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 external k8s endpoint, which you rewrite (see # k8s-rewrite-external.filter). {+client-header-filter{k8s-rewrite-external} -block{Kubernetes}} CLUSTER_IP/

  5. Crie o arquivo k8s-rewrite-external.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-external\
     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 external cluster IP EXTERNAL_IP=$(curl -SsL --insecure https://kubernetes.default/api | jq -r '.serverAddressByClientCIDRs[0].serverAddress')
    # Replace CLUSTER_IP in the rewrite filter and action file sed -i "s/CLUSTER_IP/${EXTERNAL_IP}/g"\ /etc/privoxy/k8s-rewrite-external.filter sed -i "s/CLUSTER_IP/${EXTERNAL_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. Para [YOUR_PROJECT], substitua o código do seu projeto.

    docker build -t gcr.io/[YOUR_PROJECT]/k8s-api-proxy:0.1 .
    docker push gcr.io/[YOUR_PROJECT]/k8s-api-proxy:0.1

Como implantar a imagem e o serviço

  1. Crie uma implantação do Kubernetes que exponha o contêiner que você acabou de criar. Para [YOUR_PROJECT], use o código do seu projeto.

    kubectl run k8s-api-proxy \
        --image=gcr.io/[YOUR_PROJECT]/k8s-api-proxy:0.1 \
        --port=8118

  2. No mesmo diretório, 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

  3. Implante o balanceador de carga interno:

    kubectl create -f ilb.yaml

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

  5. Determine o endereço IP mestre do cluster para teste:

    gcloud container clusters list

    Nos resultados, anote o valor de MASTER_IP referente ao cluster:

    NAME      LOCATION       MASTER_VERSION  MASTER_IP       MACHINE_TYPE   NODE_VERSION  NUM_NODES  STATUS
    frobnitz  us-central1-c  1.9.7-gke.3     35.188.209.220  n1-standard-1  1.9.7-gke.3   3          RUNNING

  6. Para verificar se o proxy é utilizável, crie uma instância do Compute Engine na mesma rede, acesse-a com SSH e verifique o proxy. Para [YOUR_SUBNET], [YOUR_PROXY] e [MASTER_IP], use os valores que você conseguiu anteriormente.

    gcloud compute instances create \
        --subnet=[YOUR_SUBNET] proxy-test
    gcloud compute ssh proxy-test -- \
        curl --insecure -x [YOUR_PROXY]:8118 https://[MASTER_IP]/api

  7. 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. Para [YOUR_PROXY], use o endereço IP externo que você conseguiu na etapa anterior.

    export https_proxy=[YOUR_PROXY]:8118

  8. Teste seu proxy e a variável https_proxy:

    kubectl get pods

Como fazer a limpeza

Para evitar cobranças dos recursos usados neste tutorial na conta do Google Cloud Platform, siga estas etapas:

  • Exclua o cluster.
  • Exclua todos os endereços IP externos criados para sua instância do Compute Engine.

Excluir o cluster

Se você criou um cluster apenas para este tutorial e não quiser usá-lo para outra finalidade, é possível excluí-lo. Na linha de comando da máquina cliente, execute o seguinte comando:

gcloud container clusters delete frobnitz \
    --zone us-central1-c

Excluir endereço IP externo e instância

Se você criou uma instância do Compute Engine para o acesso externo inicial, exclua essa instância e qualquer IP externo associado a ela.

Encontre o nome da instância criada e a exclua:

gcloud compute instances list
gcloud compute instances delete [NAME]

Da mesma maneira, procure o endereço externo reservado e exclua-o:

gcloud compute addresses list
gcloud compute addresses delete [NAME]

Próximas etapas

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

Enviar comentários sobre…