Exponha um gateway de entrada através de um balanceador de carga externo

Nota: este guia só suporta a Cloud Service Mesh com APIs Istio e não suporta Google Cloud APIs. Para mais informações, consulte o artigo Vista geral do Cloud Service Mesh.

Vista geral

Com a Cloud Service Mesh, pode implementar e gerir gateways de entrada como parte da sua service mesh. Pode configurar ainda mais o equilíbrio de carga para o seu cluster com a Cloud Service Mesh através de equilibradores de carga externos (equilibradores de carga físicos ou de software fora do cluster) para enviar tráfego para o gateway de entrada.

Esta página mostra como configurar um equilibrador de carga externo com a Cloud Service Mesh. Em alternativa, pode configurar a entrada com várias configurações de back-end.

Antes de começar

Para concluir os passos neste documento, precisa dos seguintes recursos:

• Um cluster do Kubernetes com o Cloud Service Mesh instalado.

• Um balanceador de carga externo que pode aceder aos nós onde o cluster está a ser executado. Configura este balanceador de carga externo para ficar à frente do gateway de entrada do cluster através do endereço IP externo do balanceador de carga.

Configure o seu ambiente

Execute os seguintes comandos a partir de uma estação de trabalho que possa aceder ao cluster que pretende usar. Certifique-se de que a ferramenta kubectl está configurada para usar o contexto do cluster específico do seu cluster.

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. [\Optional/] Etiquete os nós da gateway de entrada. Isto garante que o gateway é implementado em nós específicos no cluster.

   kubectl label nodes INGRESSGATEWAY_NODE_IP ${ASM_INGRESSGATEWAY_NODE_LABEL}=
   

   • INGRESSGATEWAY_NODE_IP: são os nós no seu cluster do Kubernetes que alojam o gateway de entrada. Execute este comando kubectl para todos os nós de entrada que tiver.

Crie o gateway de entrada

Antes de concluir as instruções nesta secção, tem de determinar a implementação do plano de controlo. Use as instruções em Identifique a implementação do plano de controlo para o fazer.

1. Crie o espaço de nomes. Este espaço de nomes é usado para implementar o gateway de entrada.

   kubectl create namespace ${ASM_INGRESSGATEWAY_NAMESPACE}
   

1. Ative o espaço de nomes para injeção. Os passos dependem da sua implementação do plano de controlo.

   Gerido (TD)

   1. Aplique a etiqueta de injeção predefinida ao espaço de nomes:

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

   Gerido (Istiod)

   Recomendado: execute o seguinte comando para aplicar a etiqueta de injeção predefinida ao espaço de nomes:

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

   Se for um utilizador existente com o plano de controlo do Istiod gerido: recomendamos que use a injeção predefinida, mas a injeção baseada em revisões é suportada. Siga as instruções abaixo:

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

      kubectl -n istio-system get controlplanerevision
      

      O resultado é semelhante ao seguinte:

      NAME                AGE
      asm-managed-rapid   6d7h
      

      NOTA: se aparecerem duas revisões do plano de controlo na lista acima, remova uma delas. Ter vários canais do plano de controlo no cluster não é suportado.

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

   2. Aplique a etiqueta de revisão ao espaço de nomes:

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

   No cluster

   Recomendado: execute o seguinte comando para aplicar a etiqueta de injeção predefinida ao espaço de nomes:

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

   Recomendamos que use a injeção predefinida, mas a injeção baseada em revisões é suportada: siga estas instruções:

   1. Use o seguinte comando para localizar a etiqueta 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 a etiqueta de revisão ao espaço de nomes. No comando seguinte, REVISION_LABEL é o valor da etiqueta de revisão istiod que anotou no passo anterior.

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

2. Aplique o ficheiro de manifesto da 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
   

   Resultado esperado:

   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. Aplique uma correção ao 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 uma patch à implementação da afinidade de etiquetas dos nós do gateway de entrada.ingressgateway

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

Configure o balanceador de carga externo

Nesta secção, configura o balanceador de carga externo para estabelecer ligação ao gateway de entrada do cluster.

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

1. Apanhe a linha 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. Apresentar o NodePorts.

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

Configure o balanceador de carga externo

Use o NodePorts apresentado no passo anterior para configurar a conetividade entre o equilibrador de carga externo e o gateway de entrada.

1. Configure a verificação de funcionamento 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 seu cluster do Kubernetes que aloja o gateway de entrada. Este endereço IP tem de estar acessível a partir do seu balanceador de carga externo. Pode ter de configurar esta configuração várias vezes, uma vez por nó do cluster.

   • STATUS_PORT: é o NodePort através do qual a API de estado de funcionamento do gateway de entrada é exposta. Pode copiar estas informações do passo anterior. O valor é o mesmo para todos os nós no cluster.

2. Configure pools de nós no balanceador de carga para encaminhar o tráfego HTTP e HTTPS. Use a seguinte configuração de IP:PORT para o tráfego na porta 80 (HTTP) e na porta 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 seu cluster do Kubernetes que aloja o gateway de entrada. Este endereço IP tem de estar acessível a partir do seu balanceador de carga externo. Pode ter de configurar esta configuração várias vezes, uma vez por nó do cluster.

   • HTTP_INGRESS_PORT: é a NodePort através da qual o tráfego HTTP do gateway de entrada é exposto. Pode copiar estas informações do passo anterior. O valor é o mesmo para todos os nós no cluster.

   • HTTPS_INGRESS_PORT: é a NodePort através da qual o tráfego HTTPS do gateway de entrada é exposto. Pode copiar estas informações do passo anterior. O valor é o mesmo para todos os nós no cluster.

Para validar a configuração, certifique-se de que as verificações de funcionamento no balanceador de carga estão a ser aprovadas.

O que se segue?

• Leia mais sobre a instalação e a atualização de gateways