Versione 1.15

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Esporre un gateway in entrata utilizzando un bilanciatore del carico esterno

Panoramica

Con Anthos Service Mesh puoi implementare e gestire i gateway in entrata come parte del tuo mesh di servizi. Puoi configurare ulteriormente il bilanciamento del carico per il tuo cluster con Anthos Service Mesh utilizzando bilanciatori del carico esterni (bilanciatori del carico fisici o software all'esterno del cluster) per inviare il traffico al gateway in entrata.

Questa pagina mostra come configurare un bilanciatore del carico esterno con Anthos Service Mesh.

Prima di iniziare

Per completare i passaggi descritti in questo documento, devi disporre delle seguenti risorse:

  • Un cluster Kubernetes con Anthos Service Mesh installato.

  • Un bilanciatore di carico esterno che può accedere ai nodi in cui è in esecuzione il cluster. Configurerai questo bilanciatore del carico esterno per il gateway in entrata del cluster tramite il External IP Address.

Configura l'ambiente

Esegui i comandi seguenti da una workstation in grado di accedere al cluster che intendi utilizzare. Assicurati che lo strumento kubectl sia configurato per utilizzare il contesto del cluster specifico per il cluster.

  1. Imposta le variabili di 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. Imposta il IP address del bilanciatore del carico esterno.

    export EXTERNAL_LB_IP_ADDRESS=EXTERNAL_LB_IP_ADDRESS
    
  3. [Facoltativo] Etichetta i nodi del gateway in entrata. Ciò garantisce che il gateway venga eseguito in nodi specifici nel cluster.

    kubectl label nodes INGRESSGATEWAY_NODE_IP ${ASM_INGRESSGATEWAY_NODE_LABEL}=
    
    • INGRESSGATEWAY_NODE_IP: nodo è nel tuo cluster Kubernetes che ospita il gateway in entrata. Esegui questo comando kubectl per tutti i nodi in entrata che hai.

Crea il gateway in entrata

  1. Creare lo spazio dei nomi. Questo spazio dei nomi verrà utilizzato per il deployment del gateway in entrata.

    kubectl create namespace ${ASM_INGRESSGATEWAY_NAMESPACE}
    
  2. Abilita lo spazio dei nomi per l'iniezione. I passaggi dipendono dal tipo di Anthos Service Mesh (gestito o in-cluster).

    Gestita

    1. Utilizza il seguente comando per individuare i canali di rilascio disponibili:

      kubectl -n istio-system get controlplanerevision
      

      L'output è simile al seguente:

      NAME                AGE
      asm-managed         6d7h
      asm-managed-rapid   6d7h
      

      Nell'output, il valore nella colonna NAME è l'etichetta di revisione corrispondente al canale di rilascio disponibile per la versione di Anthos Service Mesh.

    2. Applica l'etichetta di revisione allo spazio dei nomi:

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

    Nel cluster

    1. Utilizza il comando seguente per individuare l'etichetta di revisione su istiod:

      kubectl get deploy -n istio-system -l app=istiod -o \
        jsonpath={.items[*].metadata.labels.'istio\.io\/rev'}'{"\n"}'
      
    2. Applica l'etichetta di revisione allo spazio dei nomi. Nel comando seguente, REVISION è il valore dell'etichetta di revisione istiod che hai annotato nel passaggio precedente.

      kubectl label namespace ${ASM_INGRESSGATEWAY_NAMESPACE} \
        istio-injection- istio.io/rev=REVISION --overwrite
      
  3. Applica il file manifest del gateway in entrata.

    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
    

    Output previsto:

    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. Applica una patch al servizio ingressgateway all'indirizzo IP del bilanciatore del carico esterno.

    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. (Facoltativo) Applica una patch al deployment ingressgateway per l'affinità etichetta dei nodi del gateway in entrata.

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

Configura il bilanciatore del carico esterno

In questa sezione configurerai il bilanciatore del carico esterno in modo che si connetta al gateway in entrata dal cluster.

Recupera informazioni sulla porta Service del gateway in entrata

  1. Acquista 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. Visualizza NodePorts.

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

Configura il bilanciatore del carico esterno

Utilizza il NodePorts visualizzato nel passaggio precedente per configurare la connettività tra il bilanciatore del carico esterno e il gateway in entrata.

  1. Configura il controllo di integrità nella configurazione del bilanciatore del carico.

    hosts:    CLUSTER_NODE_IP
    Protocol: HTTP
    Port:     STATUS_PORT
    Path:     /healthz/ready
    
    • CLUSTER_NODE_IP: è l'indirizzo IP dei nodi nel tuo cluster Kubernetes che ospita il gateway in entrata. Questo indirizzo IP deve essere raggiungibile dal bilanciatore del carico esterno. Potrebbe essere necessario impostare questa configurazione più volte, una volta per nodo del cluster.

    • STATUS_PORT: è il NodePort tramite il quale viene esposta l'API dello stato di integrità del gateway in entrata. Puoi copiare queste informazioni dal passaggio precedente. sarà lo stesso per tutti i nodi del cluster.

  2. Configura i pool di nodi nel tuo bilanciatore del carico per il routing del traffico HTTP e HTTPS. Utilizza la seguente configurazione IP:PORT per il traffico sulla porta 80 (HTTP) e sulla porta 443 (HTTPS).

    80  ->  CLUSTER_NODE_IP:HTTP_INGRESS_PORT
    443 ->  CLUSTER_NODE_IP:HTTPS_INGRESS_PORT
    
    • CLUSTER_NODE_IP: è l'indirizzo IP dei nodi nel tuo cluster Kubernetes che ospita il gateway in entrata. Questo indirizzo IP deve essere raggiungibile dal bilanciatore del carico esterno. Potrebbe essere necessario impostare questa configurazione più volte, una volta per nodo del cluster.

    • HTTP_INGRESS_PORT: è il NodePort attraverso il quale viene esposto il traffico HTTP del gateway in entrata. Puoi copiare queste informazioni dal passaggio precedente. sarà lo stesso per tutti i nodi del cluster.

    • HTTPS_INGRESS_PORT: è il NodePort tramite cui viene esposto il traffico HTTPS del gateway in entrata. Puoi copiare queste informazioni dal passaggio precedente. sarà lo stesso per tutti i nodi del cluster.

Per verificare la configurazione, assicurati che i controlli di integrità del bilanciatore del carico siano stati superati.

Passaggi successivi