Expor um gateway de entrada usando um balanceador de carga externo

Observação: este guia só oferece suporte ao Cloud Service Mesh com APIs do Istio e não oferece suporte às APIs do Google Cloud. Para mais informações, consulte Visão geral do Cloud Service Mesh.

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 melhor o balanceamento de carga para o cluster com o Cloud Service Mesh usando balanceadores de carga externos (físicos balanceadores de carga de software fora do cluster) para enviar tráfego à entrada gateway de VPN de alta disponibilidade.

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. Configure esse balanceador de carga externo para atender à entrada gateway do seu 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/] Rotule 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, determine a implementação do plano de controle. Use as instruções Identifique a implementação do plano de controle para fazer isso.

1. Crie o namespace. Esse namespace é usado para implantar o Ingress gateway de VPN de alta disponibilidade.

   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 seguinte comando 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 seguinte comando 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 é compatível: 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 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 o tráfego HTTPS 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.

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