Versão 1.15

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Expor um gateway de entrada usando um balanceador de carga externo

Visão geral

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.

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.

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

  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