Ingress-Gateway mithilfe eines externen Load-Balancers verfügbar machen

Übersicht

Mit Cloud Service Mesh können Sie Ingress-Gateways als Teil Ihres Service Mesh bereitstellen und verwalten. Sie können das Load-Balancing für Ihren Cluster weiter konfigurieren mit Cloud Service Mesh über externe Load-Balancer (physische oder Software-Load-Balancer außerhalb des Clusters), um Traffic an den Ingress zu senden Gateway.

Auf dieser Seite erfahren Sie, wie Sie einen externen Load Balancer mit Cloud Service Mesh konfigurieren. Alternativ können Sie Ingress mit mehreren Backend-Konfigurationen einrichten.

Hinweise

Zum Ausführen der Schritte in diesem Dokument benötigen Sie die folgenden Ressourcen:

  • Ein Kubernetes-Cluster mit installiertem Cloud Service Mesh.

  • Einen externen Load Balancer, der auf die Knoten zugreifen kann, auf denen Ihr Cluster ausgeführt wird. Sie konfigurieren diesen externen Load-Balancer für eingehenden Traffic Gateway Ihres Clusters mithilfe der externen IP-Adresse des Load-Balancers.

Umgebung einrichten

Führen Sie die folgenden Befehle auf einer Workstation aus, die auf den Cluster zugreifen kann die Sie nutzen möchten. Achten Sie darauf, dass das kubectl-Tool so konfiguriert ist, dass es den für Ihren Cluster spezifischen Clusterkontext verwendet.

  1. Legen Sie die Umgebungsvariablen fest.

    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. Legen Sie die IP address des externen Load-Balancers fest.

    export EXTERNAL_LB_IP_ADDRESS=EXTERNAL_LB_IP_ADDRESS
    
  3. [Optional] Kennzeichnen Sie die Ingress-Gateway-Knoten. Dadurch wird das Gateway für bestimmte Knoten im Cluster bereitgestellt.

    kubectl label nodes INGRESSGATEWAY_NODE_IP ${ASM_INGRESSGATEWAY_NODE_LABEL}=
    
    • INGRESSGATEWAY_NODE_IP sind die Knoten in Ihrem Kubernetes-Cluster, die das Ingress-Gateway hosten. Führen Sie diesen kubectl-Befehl für als Ingress-Knoten haben.

Ingress-Gateway erstellen

Bevor Sie mit der Anleitung in diesem Abschnitt fortfahren, müssen Sie die Implementierung Ihrer Steuerungsebene festlegen. Folgen Sie dazu der Anleitung unter Steuerungsebenenimplementierung ermitteln.

  1. Erstellen Sie den Namespace. Dieser Namespace wird zum Bereitstellen des Ingress-Gateways verwendet.

    kubectl create namespace ${ASM_INGRESSGATEWAY_NAMESPACE}
    
  1. Aktivieren Sie den Namespace für die Injection: Die Schritte hängen von Ihrer Implementierung der Steuerungsebene ab.

    Verwaltet (TD)

    1. Wenden Sie das Standard-Injection-Label auf den Namespace an:
    kubectl label namespace ${ASM_INGRESSGATEWAY_NAMESPACE} \
        istio.io/rev- istio-injection=enabled --overwrite
    

    Verwaltet (Istiod)

    Empfohlen:Führen Sie den folgenden Befehl aus, um das Standard-Injection-Label auf den Namespace anzuwenden:

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

    Wenn Sie bereits Nutzer mit der Managed Istiod-Steuerungsebene sind: Wir empfehlen die Standardeinschleusung, aber die überarbeitete Injektion ist unterstützt. Gehe dazu so vor:

    1. Führen Sie den folgenden Befehl aus, um die verfügbaren Release-Versionen zu finden:

      kubectl -n istio-system get controlplanerevision
      

      Die Ausgabe sieht in etwa so aus:

      NAME                AGE
      asm-managed-rapid   6d7h
      

      HINWEIS: Wenn in der Liste oben zwei Überarbeitungen der Steuerungsebene angezeigt werden, entfernen Sie eine. Mehrere Steuerungsebenenkanäle im Cluster werden nicht unterstützt.

      In der Ausgabe ist der Wert in der NAME-Spalte das Überarbeitungslabel, das dem verfügbaren Release-Kanal für die Cloud Service Mesh-Version entspricht.

    2. Wenden Sie das Überarbeitungslabel auf den Namespace an.

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

    Clusterintern

    Empfohlen:Führen Sie den folgenden Befehl aus, um das Standard-Injection-Label auf den Namespace anzuwenden:

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

    Wir empfehlen die Standardeinschleusung, aber die versionsbasierte Einschleusung wird unterstützt: Gehe dazu so vor:

    1. Verwenden Sie den folgenden Befehl, um das Überarbeitungslabel für istiod zu finden:

      kubectl get deploy -n istio-system -l app=istiod -o \
         jsonpath={.items[*].metadata.labels.'istio\.io\/rev'}'{"\n"}'
      
    2. Wenden Sie das Überarbeitungslabel auf den Namespace an. Im folgenden Befehl ist REVISION_LABEL der Wert des Überarbeitungslabels istiod, den Sie im vorherigen Schritt notiert haben.

      kubectl label namespace ${ASM_INGRESSGATEWAY_NAMESPACE} \
          istio-injection- istio.io/rev=REVISION_LABEL --overwrite
      
  2. Wenden Sie die Manifestdatei des Ingress-Gateways an.

    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
    

    Erwartete Ausgabe:

    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. Patchen Sie den Dienst ingressgateway mit der IP-Adresse des externen Load-Balancers.

    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. [Optional] Patchen Sie die ingressgateway-Bereitstellung für die Labelaffinität des Ingress-Gateway-Knotens.

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

Externen Load-Balancer einrichten

In diesem Abschnitt konfigurieren Sie den externen Load Balancer, um eine Verbindung zum Ingress-Gateway aus dem Cluster herzustellen.

Portinformationen des Service-Ports für eingehenden Traffic abrufen

  1. Rufen Sie die NodePorts ab.

    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. Zeigen Sie die NodePorts an.

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

Externes Lastenausgleichsmodul konfigurieren

Verwenden Sie das im vorherigen Schritt angezeigte NodePorts, um die Konnektivität zu konfigurieren dem externen Load-Balancer und dem Ingress-Gateway.

  1. Konfigurieren Sie die Systemdiagnose in der Load-Balancer-Konfiguration.

    hosts:    CLUSTER_NODE_IP
    Protocol: HTTP
    Port:     STATUS_PORT
    Path:     /healthz/ready
    
    • CLUSTER_NODE_IP: ist die IP-Adresse der Knoten in Ihrem Kubernetes-Cluster, der das Ingress-Gateway hostet. Diese IP-Adresse muss die über Ihren externen Load-Balancer erreichbar sind. Möglicherweise müssen Sie diese Konfiguration mehrmals, einmal pro Clusterknoten.

    • STATUS_PORT ist der NodePort, über den die Systemdiagnose-API des Ingress-Gateways bereitgestellt wird. Sie können diese Informationen aus dem vorherigen Schritt kopieren. Der Wert ist für jeden Knoten im Cluster gleich.

  2. Konfigurieren Sie Knotenpools in Ihrem Load Balancer für das Routing von HTTP- und HTTPS-Traffic. Verwenden Sie die folgende IP:PORT-Konfiguration für Traffic über Port 80 (HTTP) und Port 443 (HTTPS).

    80  ->  CLUSTER_NODE_IP:HTTP_INGRESS_PORT
    443 ->  CLUSTER_NODE_IP:HTTPS_INGRESS_PORT
    
    • CLUSTER_NODE_IP: ist die IP-Adresse der Knoten in Ihrem Kubernetes-Cluster, der das Ingress-Gateway hostet. Diese IP-Adresse muss von Ihrem externen Load Balancer aus erreichbar sein. Möglicherweise müssen Sie diese Konfiguration mehrmals einrichten, einmal pro Clusterknoten.

    • HTTP_INGRESS_PORT ist der NodePort, über den der HTTP-Traffic des Ingress-Gateways bereitgestellt wird. Sie können diese Informationen aus dem vorherigen Schritt. Der Wert ist für jeden Knoten im Cluster gleich.

    • HTTPS_INGRESS_PORT: ist die NodePort, über die der wird der HTTPS-Traffic des Ingress-Gateways gefährdet. Sie können diese Informationen aus dem vorherigen Schritt kopieren. Der Wert ist für jeden Knoten im Cluster gleich.

Stellen Sie zum Prüfen der Einrichtung sicher, dass die Systemdiagnosen Ihres Load-Balancers korrekt sind bestanden werden.

Nächste Schritte