Expor um gateway de entrada usando um balanceador de carga externo

Visão geral

Com o Cloud Service Mesh, é possível implantar e gerenciar gateways de entrada como parte da malha de serviço. É possível configurar ainda mais o balanceamento de carga do cluster com o Cloud Service Mesh usando balanceadores de carga externos (físicos ou de software fora do cluster) para enviar tráfego ao gateway de entrada.

Nesta página, mostramos como configurar um balanceador de carga externo com o Cloud Service Mesh. Se preferir, configure a entrada com várias configurações de back-end.

Antes de começar

Para concluir as etapas deste documento, você precisa dos seguintes recursos:

  • Um cluster do Kubernetes com o Cloud Service Mesh instalado

  • Um balanceador de carga externo que pode acessar os nós em que o cluster está sendo executado. Você configura esse balanceador de carga externo para ser usado no gateway de entrada do cluster usando o endereço IP externo do balanceador de carga.

Configurar o ambiente

Execute os comandos a seguir em uma estação de trabalho que possa acessar o cluster que você pretende usar. Verifique se a ferramenta kubectl está configurada para usar o contexto do cluster específico.

  1. Defina as variáveis de ambiente.

    export ASM_INGRESSGATEWAY_NAMESPACE=asm-ingressgateway
    export ASM_INGRESSGATEWAY_DEPLOYMENT_NAME=asm-ingressgateway
    export ASM_INGRESSGATEWAY_SERVICE_NAME=asm-ingressgateway
    export ASM_INGRESSGATEWAY_NODE_LABEL=asm-ingressgateway
    
  2. Defina o IP address do balanceador de carga externo.

    export EXTERNAL_LB_IP_ADDRESS=EXTERNAL_LB_IP_ADDRESS
    
  3. [\Opcional/] Identifique os nós do gateway de entrada. Isso garante que o gateway seja implantado em nós específicos do cluster.

    kubectl label nodes INGRESSGATEWAY_NODE_IP ${ASM_INGRESSGATEWAY_NODE_LABEL}=
    
    • INGRESSGATEWAY_NODE_IP: são os nós no cluster do Kubernetes que hospeda o gateway de entrada. Execute este comando kubectl para quantos nós de entrada você tiver.

Criar o gateway de entrada

Antes de seguir as instruções desta seção, você precisa determinar a implementação do plano de controle. Para fazer isso, siga as instruções em Identificar a implementação do plano de controle.

  1. Crie o namespace. Esse namespace é usado para implantar o gateway de entrada.

    kubectl create namespace ${ASM_INGRESSGATEWAY_NAMESPACE}
    
  1. Ativar o namespace para injeção. As etapas dependem da implementação do plano de controle.

    Gerenciado (TD)

    1. Aplique o rótulo de injeção padrão ao namespace:
    kubectl label namespace ${ASM_INGRESSGATEWAY_NAMESPACE} \
        istio.io/rev- istio-injection=enabled --overwrite
    

    Gerenciado (Istiod)

    Recomendado: execute o comando a seguir para aplicar o rótulo de injeção padrão ao namespace:

      kubectl label namespace ${ASM_INGRESSGATEWAY_NAMESPACE} \
          istio.io/rev- istio-injection=enabled --overwrite
    

    Se você for um usuário com o plano de controle Managed Istiod: Recomendamos que você use a injeção padrão, mas a injeção baseada em revisão é suporte. Siga estas instruções:

    1. Execute o seguinte comando para localizar os canais de lançamento disponíveis:

      kubectl -n istio-system get controlplanerevision
      

      O resultado será assim:

      NAME                AGE
      asm-managed-rapid   6d7h
      

      OBSERVAÇÃO: se duas revisões do plano de controle aparecerem na lista acima, remova uma. Não é possível ter vários canais de plano de controle no cluster.

      Na saída, o valor na coluna NAME é o rótulo de revisão que corresponde ao canal de lançamento disponível para a versão do Cloud Service Mesh.

    2. Aplique o rótulo de revisão ao namespace:

      kubectl label namespace ${ASM_INGRESSGATEWAY_NAMESPACE} \
          istio-injection- istio.io/rev=REVISION_LABEL --overwrite
      

    No cluster

    Recomendado: execute o comando a seguir para aplicar o rótulo de injeção padrão ao namespace:

      kubectl label namespace ${ASM_INGRESSGATEWAY_NAMESPACE} \
          istio.io/rev- istio-injection=enabled --overwrite
    

    Recomendamos que você use a injeção padrão, mas a injeção baseada em revisão tem suporte: Siga estas instruções:

    1. Use o seguinte comando para localizar o rótulo de revisão em istiod:

      kubectl get deploy -n istio-system -l app=istiod -o \
         jsonpath={.items[*].metadata.labels.'istio\.io\/rev'}'{"\n"}'
      
    2. Aplique o rótulo de revisão ao namespace. No comando a seguir, REVISION_LABEL é o valor do rótulo de revisão istiod que você anotou na etapa anterior.

      kubectl label namespace ${ASM_INGRESSGATEWAY_NAMESPACE} \
          istio-injection- istio.io/rev=REVISION_LABEL --overwrite
      
  2. Aplique o arquivo de manifesto do gateway de entrada.

    kubectl --namespace ${ASM_INGRESSGATEWAY_NAMESPACE} apply --filename https://raw.githubusercontent.com/GoogleCloudPlatform/anthos-service-mesh-samples/main/docs/ingress-gateway-external-lb/ingress-gateway.yaml
    

    Saída esperada:

    serviceaccount/asm-ingressgateway created
    role.rbac.authorization.k8s.io/asm-ingressgateway created
    rolebinding.rbac.authorization.k8s.io/asm-ingressgateway created
    deployment.apps/asm-ingressgateway created
    service/asm-ingressgateway created
    poddisruptionbudget.policy/asm-ingressgateway created
    horizontalpodautoscaler.autoscaling/asm-ingressgateway created
    
  3. Corrija o serviço ingressgateway com o endereço IP do balanceador de carga externo.

    cat <<EOF > asm-external-ip-patch.yaml
    spec:
      externalIPs:
        - ${EXTERNAL_LB_IP_ADDRESS}
      loadBalancerIP: ${EXTERNAL_LB_IP_ADDRESS}
    EOF
    
    kubectl --namespace ${ASM_INGRESSGATEWAY_NAMESPACE} patch service/${ASM_INGRESSGATEWAY_SERVICE_NAME} --patch "$(cat asm-external-ip-patch.yaml)"
    
  4. [Opcional] Aplique patch à implantação ingressgateway para a afinidade de rótulo dos nós do gateway de entrada.

    cat <<EOF > asm-ingress-node-label-patch.yaml
    spec:
      template:
        spec:
          affinity:
            nodeAffinity:
              requiredDuringSchedulingIgnoredDuringExecution:
                nodeSelectorTerms:
                - matchExpressions:
                  - key: ${ASM_INGRESSGATEWAY_NODE_LABEL}
                    operator: Exists
    EOF
    
    kubectl --namespace ${ASM_INGRESSGATEWAY_NAMESPACE} patch deployment/${ASM_INGRESSGATEWAY_DEPLOYMENT_NAME} --patch "$(cat asm-ingress-node-label-patch.yaml)"
    

Configurar o balanceador de carga externo

Nesta seção, você vai configurar o balanceador de carga externo para se conectar ao gateway de entrada do cluster.

Buscar informações da porta Service do gateway de entrada

  1. Gere o NodePorts.

    export HTTP_INGRESS_PORT=$(kubectl --namespace ${ASM_INGRESSGATEWAY_NAMESPACE} get service/${ASM_INGRESSGATEWAY_SERVICE_NAME} --output jsonpath='{.spec.ports[?(@.name=="http2")].nodePort}')
    export HTTPS_INGRESS_PORT=$(kubectl --namespace ${ASM_INGRESSGATEWAY_NAMESPACE} get service/${ASM_INGRESSGATEWAY_SERVICE_NAME} --output jsonpath='{.spec.ports[?(@.name=="https")].nodePort}')
    export STATUS_PORT=$(kubectl --namespace ${ASM_INGRESSGATEWAY_NAMESPACE} get service/${ASM_INGRESSGATEWAY_SERVICE_NAME} --output jsonpath='{.spec.ports[?(@.name=="status-port")].nodePort}')
    
  2. Exiba o NodePorts.

    echo HTTP_INGRESS_PORT=${HTTP_INGRESS_PORT}
    echo HTTPS_INGRESS_PORT=${HTTPS_INGRESS_PORT}
    echo STATUS_PORT=${STATUS_PORT}
    

Configurar o balanceador de carga externo

Use o NodePorts exibido na etapa anterior para configurar a conectividade entre o balanceador de carga externo e o gateway de entrada.

  1. Defina a verificação de integridade na configuração do balanceador de carga.

    hosts:    CLUSTER_NODE_IP
    Protocol: HTTP
    Port:     STATUS_PORT
    Path:     /healthz/ready
    
    • CLUSTER_NODE_IP: é o endereço IP dos nós no cluster do Kubernetes que hospeda o gateway de entrada. Esse endereço IP precisa ser acessado pelo balanceador de carga externo. Talvez seja necessário definir essa configuração várias vezes, uma para cada nó de cluster.

    • STATUS_PORT: é o NodePort pelo qual a API de status de integridade do gateway de entrada é exposta. Você pode copiar essas informações da etapa anterior. O valor é o mesmo para todos os nós do cluster.

  2. Configure pools de nós no balanceador de carga para rotear o tráfego HTTP e HTTPS. Use a seguinte configuração de IP:PORT para o tráfego nas portas 80 (HTTP) e 443 (HTTPS).

    80  ->  CLUSTER_NODE_IP:HTTP_INGRESS_PORT
    443 ->  CLUSTER_NODE_IP:HTTPS_INGRESS_PORT
    
    • CLUSTER_NODE_IP: é o endereço IP dos nós no cluster do Kubernetes que hospeda o gateway de entrada. Esse endereço IP precisa ser acessado pelo balanceador de carga externo. Talvez seja necessário definir essa configuração várias vezes, uma para cada nó de cluster.

    • HTTP_INGRESS_PORT: é o NodePort pelo qual o o tráfego HTTP do gateway de entrada fica exposto. Você pode copiar essas informações da etapa anterior. O valor é o mesmo para todos os nós do cluster.

    • HTTPS_INGRESS_PORT: é o NodePort pelo qual o tráfego HTTPS do gateway de entrada é exposto. Você pode copiar essas informações da etapa anterior. O valor é o mesmo para todos os nós do cluster.

Para verificar a configuração, confira se as verificações de integridade do balanceador de carga estão sendo aprovadas.

A seguir