Expor um gateway de entrada usando um balanceador de carga externo

Informações gerais

Com o Anthos 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 Anthos 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 Anthos 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 Anthos 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 Anthos 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 Anthos 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