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ê vai configurar este balanceador de carga externo para ser usado no gateway de entrada do cluster pelo External IP Address.

Configure seu 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

1. Crie o namespace. Ele será usado para implantar o gateway de entrada.

   kubectl create namespace ${ASM_INGRESSGATEWAY_NAMESPACE}
   

2. Ativar o namespace para injeção. As etapas dependem do tipo de Cloud Service Mesh (gerenciado ou no cluster).

   Gerenciado

   1. Use 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         6d7h
      asm-managed-rapid   6d7h
      

      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

   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 é 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 --overwrite
      

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

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

5. [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 com que a API de status de integridade do gateway de entrada é exposta. Você pode copiar essas informações da etapa anterior. Ela será igual 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 tráfego HTTP do gateway de entrada é exposto. Você pode copiar essas informações da etapa anterior. Ela será igual 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. Ela será igual 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

• Leia mais sobre Como instalar e fazer upgrade de gateways